From 0cc40db565a9c4b99e6fa0844b9ac512558626e4 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 8 Feb 2022 17:04:55 +0000 Subject: [PATCH 01/64] Begin work on support objc intrinsics --- src/check_builtin.cpp | 223 +++++++++++++++++++++++++++++++++- src/check_decl.cpp | 3 + src/checker.cpp | 36 ++++++ src/checker.hpp | 15 ++- src/checker_builtin_procs.hpp | 6 + src/entity.cpp | 1 + src/llvm_backend.cpp | 59 ++++++++- src/llvm_backend.hpp | 6 +- src/llvm_backend_general.cpp | 8 +- src/llvm_backend_proc.cpp | 3 + src/llvm_backend_utility.cpp | 96 +++++++++++++++ src/types.cpp | 10 ++ 12 files changed, 459 insertions(+), 7 deletions(-) diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp index 1fb3d6037..8ada77b12 100644 --- a/src/check_builtin.cpp +++ b/src/check_builtin.cpp @@ -143,6 +143,219 @@ void check_or_return_split_types(CheckerContext *c, Operand *x, String const &na } +bool does_require_msgSend_stret(Type *return_type) { + if (return_type == nullptr) { + return false; + } + if (build_context.metrics.arch == TargetArch_i386 || build_context.metrics.arch == TargetArch_amd64) { + i64 struct_limit = type_size_of(t_uintptr) << 1; + return type_size_of(return_type) > struct_limit; + } + if (build_context.metrics.arch == TargetArch_arm64) { + return false; + } + + // if (build_context.metrics.arch == TargetArch_arm32) { + // i64 struct_limit = type_size_of(t_uintptr); + // // NOTE(bill): This is technically wrong + // return is_type_struct(return_type) && !is_type_raw_union(return_type) && type_size_of(return_type) > struct_limit; + // } + GB_PANIC("unsupported architecture"); + return false; +} + +ObjcMsgKind get_objc_proc_kind(Type *return_type) { + if (return_type == nullptr) { + return ObjcMsg_normal; + } + + if (build_context.metrics.arch == TargetArch_i386 || build_context.metrics.arch == TargetArch_amd64) { + if (is_type_float(return_type)) { + return ObjcMsg_fpret; + } + if (build_context.metrics.arch == TargetArch_amd64) { + if (is_type_complex(return_type)) { + // URL: https://github.com/opensource-apple/objc4/blob/cd5e62a5597ea7a31dccef089317abb3a661c154/runtime/message.h#L143-L159 + return ObjcMsg_fpret; + } + } + } + if (build_context.metrics.arch != TargetArch_arm64) { + if (does_require_msgSend_stret(return_type)) { + return ObjcMsg_stret; + } + } + return ObjcMsg_normal; +} + +void add_objc_proc_type(CheckerContext *c, Ast *call, Type *return_type, Slice param_types) { + ObjcMsgKind kind = get_objc_proc_kind(return_type); + + Scope *scope = create_scope(c->info, nullptr); + + // NOTE(bill, 2022-02-08): the backend's ABI handling should handle this correctly, I hope + Type *params = alloc_type_tuple(); + { + auto variables = array_make(permanent_allocator(), 0, param_types.count); + + for_array(i, param_types) { + Type *type = param_types[i]; + Entity *param = alloc_entity_param(scope, blank_token, type, false, true); + array_add(&variables, param); + } + params->Tuple.variables = slice_from_array(variables); + } + + Type *results = alloc_type_tuple(); + if (return_type) { + auto variables = array_make(permanent_allocator(), 1); + results->Tuple.variables = slice_from_array(variables); + Entity *param = alloc_entity_param(scope, blank_token, return_type, false, true); + results->Tuple.variables[0] = param; + } + + + ObjcMsgData data = {}; + data.kind = kind; + data.proc_type = alloc_type_proc(scope, params, param_types.count, results, results->Tuple.variables.count, false, ProcCC_CDecl); + + mutex_lock(&c->info->objc_types_mutex); + map_set(&c->info->objc_msgSend_types, call, data); + mutex_unlock(&c->info->objc_types_mutex); + + add_package_dependency(c, "runtime", "objc_lookUpClass"); + add_package_dependency(c, "runtime", "sel_registerName"); + + add_package_dependency(c, "runtime", "objc_msgSend"); + add_package_dependency(c, "runtime", "objc_msgSend_fpret"); + add_package_dependency(c, "runtime", "objc_msgSend_fp2ret"); + add_package_dependency(c, "runtime", "objc_msgSend_stret"); +} + +bool check_builtin_objc_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 id, Type *type_hint) { + auto const is_constant_string = [](CheckerContext *c, String const &builtin_name, Ast *expr, String *name_) -> bool { + Operand op = {}; + check_expr(c, &op, expr); + if (op.mode == Addressing_Constant && op.value.kind == ExactValue_String) { + if (name_) *name_ = op.value.value_string; + return true; + } + gbString e = expr_to_string(op.expr); + gbString t = type_to_string(op.type); + error(op.expr, "'%.*s' expected a constant string value, got %s of type %s", LIT(builtin_name), e, t); + gb_string_free(t); + gb_string_free(e); + return false; + }; + String builtin_name = builtin_procs[id].name; + + if (build_context.metrics.os != TargetOs_darwin) { + error(call, "'%.*s' only works on darwin", LIT(builtin_name)); + return false; + } + + + ast_node(ce, CallExpr, call); + switch (id) { + default: + GB_PANIC("Implement objective built-in procedure: %.*s", LIT(builtin_name)); + return false; + + case BuiltinProc_objc_send: { + Type *return_type = nullptr; + + Operand rt = {}; + check_expr_or_type(c, &rt, ce->args[0]); + if (rt.mode == Addressing_Type) { + return_type = rt.type; + } else if (is_operand_nil(rt)) { + return_type = nullptr; + } else { + gbString e = expr_to_string(rt.expr); + error(rt.expr, "'%.*s' expected a type or nil to define the return type of the Objective-C call, got %s", LIT(builtin_name), e); + gb_string_free(e); + return false; + } + + operand->type = return_type; + operand->mode = return_type ? Addressing_Value : Addressing_NoValue; + + String class_name = {}; + String sel_name = {}; + + Type *sel_type = t_objc_SEL; + Operand self = {}; + check_expr_or_type(c, &self, ce->args[1]); + if (self.mode == Addressing_Type) { + if (!internal_check_is_assignable_to(self.type, t_objc_object)) { + gbString t = type_to_string(self.type); + error(self.expr, "'%.*s' expected a type or value derived from intrinsics.objc_object, got type %s", LIT(builtin_name), t); + gb_string_free(t); + return false; + } + if (!(self.type->kind == Type_Named && + self.type->Named.type_name != nullptr && + self.type->Named.type_name->TypeName.objc_class_name != "")) { + gbString t = type_to_string(self.type); + error(self.expr, "'%.*s' expected a named type with the attribute @(obj_class=) , got type %s", LIT(builtin_name), t); + gb_string_free(t); + return false; + } + + sel_type = t_objc_Class; + } else if (!is_operand_value(self) || !check_is_assignable_to(c, &self, t_objc_id)) { + gbString e = expr_to_string(self.expr); + gbString t = type_to_string(self.type); + error(self.expr, "'%.*s'3 expected a type or value derived from intrinsics.objc_object, got '%s' of type %s %d", LIT(builtin_name), e, t, self.type->kind); + gb_string_free(t); + gb_string_free(e); + return false; + } else if (!is_type_pointer(self.type)) { + gbString e = expr_to_string(self.expr); + gbString t = type_to_string(self.type); + error(self.expr, "'%.*s' expected a pointer of a value derived from intrinsics.objc_object, got '%s' of type %s", LIT(builtin_name), e, t); + gb_string_free(t); + gb_string_free(e); + return false; + } else { + Type *type = type_deref(self.type); + if (!(type->kind == Type_Named && + type->Named.type_name != nullptr && + type->Named.type_name->TypeName.objc_class_name != "")) { + gbString t = type_to_string(type); + error(self.expr, "'%.*s' expected a named type with the attribute @(obj_class=) , got type %s", LIT(builtin_name), t); + gb_string_free(t); + return false; + } + } + + + if (!is_constant_string(c, builtin_name, ce->args[2], &sel_name)) { + return false; + } + + isize const arg_offset = 1; + auto param_types = slice_make(permanent_allocator(), ce->args.count-arg_offset); + param_types[0] = t_objc_id; + param_types[1] = sel_type; + + for (isize i = 2+arg_offset; i < ce->args.count; i++) { + Operand x = {}; + check_expr(c, &x, ce->args[i]); + param_types[i-arg_offset] = x.type; + } + + add_objc_proc_type(c, call, return_type, param_types); + + return true; + } break; + + case BuiltinProc_objc_create: { + GB_PANIC("TODO: BuiltinProc_objc_create"); + return false; + } break; + } +} bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 id, Type *type_hint) { ast_node(ce, CallExpr, call); @@ -179,6 +392,8 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 case BuiltinProc_len: case BuiltinProc_min: case BuiltinProc_max: + case BuiltinProc_objc_send: + case BuiltinProc_objc_create: // NOTE(bill): The first arg may be a Type, this will be checked case by case break; @@ -202,7 +417,7 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 break; } - String builtin_name = builtin_procs[id].name;; + String builtin_name = builtin_procs[id].name; if (ce->args.count > 0) { @@ -219,6 +434,10 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 GB_PANIC("Implement built-in procedure: %.*s", LIT(builtin_name)); break; + case BuiltinProc_objc_send: + case BuiltinProc_objc_create: + return check_builtin_objc_procedure(c, operand, call, id, type_hint); + case BuiltinProc___entry_point: operand->mode = Addressing_NoValue; operand->type = nullptr; @@ -3815,6 +4034,8 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 operand->type = t_hasher_proc; break; } + + } return true; diff --git a/src/check_decl.cpp b/src/check_decl.cpp index f6dade812..243dbbbc6 100644 --- a/src/check_decl.cpp +++ b/src/check_decl.cpp @@ -338,6 +338,9 @@ void check_type_decl(CheckerContext *ctx, Entity *e, Ast *init_expr, Type *def) if (decl != nullptr) { AttributeContext ac = {}; check_decl_attributes(ctx, decl->attributes, type_decl_attribute, &ac); + if (e->kind == Entity_TypeName && ac.objc_class != "") { + e->TypeName.objc_class_name = ac.objc_class; + } } diff --git a/src/checker.cpp b/src/checker.cpp index 7fb4fdb29..2ab487592 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -841,6 +841,17 @@ void add_global_enum_constant(Slice const &fields, char const *name, i GB_PANIC("Unfound enum value for global constant: %s %lld", name, cast(long long)value); } +Type *add_global_type_name(Scope *scope, String const &type_name, Type *backing_type) { + Entity *e = alloc_entity_type_name(scope, make_token_ident(type_name), nullptr, EntityState_Resolved); + Type *named_type = alloc_type_named(type_name, backing_type, e); + e->type = named_type; + set_base_type(named_type, backing_type); + if (scope_insert(scope, e)) { + compiler_error("double declaration of %.*s", LIT(e->token.string)); + } + return named_type; +} + void init_universal(void) { BuildContext *bc = &build_context; @@ -985,6 +996,17 @@ void init_universal(void) { t_f64_ptr = alloc_type_pointer(t_f64); t_u8_slice = alloc_type_slice(t_u8); t_string_slice = alloc_type_slice(t_string); + + // intrinsics types for objective-c stuff + { + t_objc_object = add_global_type_name(intrinsics_pkg->scope, str_lit("objc_object"), alloc_type_struct()); + t_objc_selector = add_global_type_name(intrinsics_pkg->scope, str_lit("objc_selector"), alloc_type_struct()); + t_objc_class = add_global_type_name(intrinsics_pkg->scope, str_lit("objc_class"), alloc_type_struct()); + + t_objc_id = alloc_type_pointer(t_objc_object); + t_objc_SEL = alloc_type_pointer(t_objc_selector); + t_objc_Class = alloc_type_pointer(t_objc_class); + } } @@ -1041,6 +1063,9 @@ void init_checker_info(CheckerInfo *i) { semaphore_init(&i->collect_semaphore); mpmc_init(&i->intrinsics_entry_point_usage, a, 1<<10); // just waste some memory here, even if it probably never used + + mutex_init(&i->objc_types_mutex); + map_init(&i->objc_msgSend_types, a); } void destroy_checker_info(CheckerInfo *i) { @@ -1073,6 +1098,9 @@ void destroy_checker_info(CheckerInfo *i) { mutex_destroy(&i->type_and_value_mutex); mutex_destroy(&i->identifier_uses_mutex); mutex_destroy(&i->foreign_mutex); + + mutex_destroy(&i->objc_types_mutex); + map_destroy(&i->objc_msgSend_types); } CheckerContext make_checker_context(Checker *c) { @@ -3161,6 +3189,14 @@ DECL_ATTRIBUTE_PROC(type_decl_attribute) { } else if (name == "private") { // NOTE(bill): Handled elsewhere `check_collect_value_decl` return true; + } else if (name == "objc_class") { + ExactValue ev = check_decl_attribute_value(c, value); + if (ev.kind != ExactValue_String || ev.value_string == "") { + error(elem, "Expected a non-empty string value for '%.*s'", LIT(name)); + } else { + ac->objc_class = ev.value_string; + } + return true; } return false; } diff --git a/src/checker.hpp b/src/checker.hpp index 9a8753efd..b812e10a4 100644 --- a/src/checker.hpp +++ b/src/checker.hpp @@ -107,6 +107,7 @@ struct AttributeContext { String thread_local_model; String deprecated_message; String warning_message; + String objc_class; DeferredProcedure deferred_procedure; bool is_export : 1; bool is_static : 1; @@ -267,6 +268,17 @@ struct UntypedExprInfo { typedef PtrMap UntypedExprInfoMap; typedef MPMCQueue ProcBodyQueue; +enum ObjcMsgKind : u32 { + ObjcMsg_normal, + ObjcMsg_fpret, + ObjcMsg_fp2ret, + ObjcMsg_stret, +}; +struct ObjcMsgData { + ObjcMsgKind kind; + Type *proc_type; +}; + // CheckerInfo stores all the symbol information for a type-checked program struct CheckerInfo { Checker *checker; @@ -340,7 +352,8 @@ struct CheckerInfo { MPMCQueue intrinsics_entry_point_usage; - + BlockingMutex objc_types_mutex; + PtrMap objc_msgSend_types; }; struct CheckerContext { diff --git a/src/checker_builtin_procs.hpp b/src/checker_builtin_procs.hpp index d833a055f..1a9d7d7a0 100644 --- a/src/checker_builtin_procs.hpp +++ b/src/checker_builtin_procs.hpp @@ -250,6 +250,9 @@ BuiltinProc__type_end, BuiltinProc___entry_point, + BuiltinProc_objc_send, + BuiltinProc_objc_create, + BuiltinProc_COUNT, }; gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = { @@ -500,4 +503,7 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = { {STR_LIT(""), 0, false, Expr_Stmt, BuiltinProcPkg_intrinsics}, {STR_LIT("__entry_point"), 0, false, Expr_Stmt, BuiltinProcPkg_intrinsics}, + + {STR_LIT("objc_send"), 3, true, Expr_Expr, BuiltinProcPkg_intrinsics}, + {STR_LIT("objc_create"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, }; diff --git a/src/entity.cpp b/src/entity.cpp index 8327a517e..4d5b3b9e1 100644 --- a/src/entity.cpp +++ b/src/entity.cpp @@ -186,6 +186,7 @@ struct Entity { Type * type_parameter_specialization; String ir_mangled_name; bool is_type_alias; + String objc_class_name; } TypeName; struct { u64 tags; diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp index 304effb7f..7941c65a3 100644 --- a/src/llvm_backend.cpp +++ b/src/llvm_backend.cpp @@ -652,7 +652,53 @@ lbProcedure *lb_create_startup_type_info(lbModule *m) { return p; } -lbProcedure *lb_create_startup_runtime(lbModule *main_module, lbProcedure *startup_type_info, Array &global_variables) { // Startup Runtime +lbProcedure *lb_create_objc_names(lbModule *main_module) { + if (build_context.metrics.os != TargetOs_darwin) { + return nullptr; + } + Type *proc_type = alloc_type_proc(nullptr, nullptr, 0, nullptr, 0, false, ProcCC_CDecl); + lbProcedure *p = lb_create_dummy_procedure(main_module, str_lit("__$init_objc_names"), proc_type); + p->is_startup = true; + return p; +} + +void lb_finalize_objc_names(lbProcedure *p) { + if (p == nullptr) { + return; + } + lbModule *m = p->module; + + LLVMPassManagerRef default_function_pass_manager = LLVMCreateFunctionPassManagerForModule(m->mod); + lb_populate_function_pass_manager(m, default_function_pass_manager, false, build_context.optimization_level); + LLVMFinalizeFunctionPassManager(default_function_pass_manager); + + LLVMSetLinkage(p->value, LLVMInternalLinkage); + lb_begin_procedure_body(p); + for_array(i, m->objc_classes.entries) { + auto const &entry = m->objc_classes.entries[i]; + String name = entry.key.string; + auto args = array_make(permanent_allocator(), 1); + args[0] = lb_const_value(m, t_cstring, exact_value_string(name)); + lbValue ptr = lb_emit_runtime_call(p, "objc_lookUpClass", args); + lb_addr_store(p, entry.value, ptr); + } + + for_array(i, m->objc_selectors.entries) { + auto const &entry = m->objc_selectors.entries[i]; + String name = entry.key.string; + auto args = array_make(permanent_allocator(), 1); + args[0] = lb_const_value(m, t_cstring, exact_value_string(name)); + lbValue ptr = lb_emit_runtime_call(p, "sel_registerName", args); + lb_addr_store(p, entry.value, ptr); + } + + lb_end_procedure_body(p); + + lb_run_function_pass_manager(default_function_pass_manager, p); + +} + +lbProcedure *lb_create_startup_runtime(lbModule *main_module, lbProcedure *startup_type_info, lbProcedure *objc_names, Array &global_variables) { // Startup Runtime LLVMPassManagerRef default_function_pass_manager = LLVMCreateFunctionPassManagerForModule(main_module->mod); lb_populate_function_pass_manager(main_module, default_function_pass_manager, false, build_context.optimization_level); LLVMFinalizeFunctionPassManager(default_function_pass_manager); @@ -666,6 +712,10 @@ lbProcedure *lb_create_startup_runtime(lbModule *main_module, lbProcedure *start LLVMBuildCall2(p->builder, LLVMGetElementType(lb_type(main_module, startup_type_info->type)), startup_type_info->value, nullptr, 0, ""); + if (objc_names) { + LLVMBuildCall2(p->builder, LLVMGetElementType(lb_type(main_module, objc_names->type)), objc_names->value, nullptr, 0, ""); + } + for_array(i, global_variables) { auto *var = &global_variables[i]; if (var->is_initialized) { @@ -1570,8 +1620,10 @@ void lb_generate_code(lbGenerator *gen) { TIME_SECTION("LLVM Runtime Type Information Creation"); lbProcedure *startup_type_info = lb_create_startup_type_info(default_module); + lbProcedure *objc_names = lb_create_objc_names(default_module); + TIME_SECTION("LLVM Runtime Startup Creation (Global Variables)"); - lbProcedure *startup_runtime = lb_create_startup_runtime(default_module, startup_type_info, global_variables); + lbProcedure *startup_runtime = lb_create_startup_runtime(default_module, startup_type_info, objc_names, global_variables); gb_unused(startup_runtime); TIME_SECTION("LLVM Global Procedures and Types"); @@ -1650,6 +1702,8 @@ void lb_generate_code(lbGenerator *gen) { } } + lb_finalize_objc_names(objc_names); + if (build_context.ODIN_DEBUG) { TIME_SECTION("LLVM Debug Info Complete Types and Finalize"); for_array(j, gen->modules.entries) { @@ -1662,6 +1716,7 @@ void lb_generate_code(lbGenerator *gen) { } + TIME_SECTION("LLVM Function Pass"); for_array(i, gen->modules.entries) { lbModule *m = gen->modules.entries[i].value; diff --git a/src/llvm_backend.hpp b/src/llvm_backend.hpp index d7093bc63..087cda22a 100644 --- a/src/llvm_backend.hpp +++ b/src/llvm_backend.hpp @@ -144,6 +144,9 @@ struct lbModule { PtrMap debug_values; Array debug_incomplete_types; + + StringMap objc_classes; + StringMap objc_selectors; }; struct lbGenerator { @@ -293,7 +296,6 @@ struct lbProcedure { bool lb_init_generator(lbGenerator *gen, Checker *c); -void lb_generate_module(lbGenerator *gen); String lb_mangle_name(lbModule *m, Entity *e); String lb_get_entity_name(lbModule *m, Entity *e, String name = {}); @@ -366,7 +368,7 @@ lbContextData *lb_push_context_onto_stack(lbProcedure *p, lbAddr ctx); lbContextData *lb_push_context_onto_stack_from_implicit_parameter(lbProcedure *p); -lbAddr lb_add_global_generated(lbModule *m, Type *type, lbValue value={}); +lbAddr lb_add_global_generated(lbModule *m, Type *type, lbValue value={}, Entity **entity_=nullptr); lbAddr lb_add_local(lbProcedure *p, Type *type, Entity *e=nullptr, bool zero_init=true, i32 param_index=0, bool force_no_init=false); void lb_add_foreign_library_path(lbModule *m, Entity *e); diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp index 2fc21b534..1c98aa77f 100644 --- a/src/llvm_backend_general.cpp +++ b/src/llvm_backend_general.cpp @@ -72,6 +72,9 @@ void lb_init_module(lbModule *m, Checker *c) { map_init(&m->debug_values, a); array_init(&m->debug_incomplete_types, a, 0, 1024); + + string_map_init(&m->objc_classes, a); + string_map_init(&m->objc_selectors, a); } bool lb_init_generator(lbGenerator *gen, Checker *c) { @@ -2450,7 +2453,7 @@ lbValue lb_find_procedure_value_from_entity(lbModule *m, Entity *e) { return {}; } -lbAddr lb_add_global_generated(lbModule *m, Type *type, lbValue value) { +lbAddr lb_add_global_generated(lbModule *m, Type *type, lbValue value, Entity **entity_) { GB_ASSERT(type != nullptr); type = default_type(type); @@ -2476,6 +2479,9 @@ lbAddr lb_add_global_generated(lbModule *m, Type *type, lbValue value) { lb_add_entity(m, e, g); lb_add_member(m, name, g); + + if (entity_) *entity_ = e; + return lb_addr(g); } diff --git a/src/llvm_backend_proc.cpp b/src/llvm_backend_proc.cpp index 7a6fac603..6de0aaed7 100644 --- a/src/llvm_backend_proc.cpp +++ b/src/llvm_backend_proc.cpp @@ -2106,6 +2106,9 @@ lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValue const &tv, res.type = t_uintptr; return res; } + + case BuiltinProc_objc_send: + return lb_handle_obj_send(p, expr); } GB_PANIC("Unhandled built-in procedure %.*s", LIT(builtin_procs[id].name)); diff --git a/src/llvm_backend_utility.cpp b/src/llvm_backend_utility.cpp index 7e2bd7daa..d92f711ba 100644 --- a/src/llvm_backend_utility.cpp +++ b/src/llvm_backend_utility.cpp @@ -1819,3 +1819,99 @@ void lb_set_wasm_export_attributes(LLVMValueRef value, String export_name) { LLVMSetVisibility(value, LLVMDefaultVisibility); LLVMAddTargetDependentFunctionAttr(value, "wasm-export-name", alloc_cstring(permanent_allocator(), export_name)); } + + +lbValue lb_lookup_runtime_procedure(lbModule *m, String const &name); + +lbValue lb_handle_obj_id(lbProcedure *p, Ast *expr) { + TypeAndValue const &tav = type_and_value_of_expr(expr); + if (tav.mode == Addressing_Type) { + Type *type = tav.type; + GB_ASSERT_MSG(type->kind == Type_Named, "%s", type_to_string(type)); + Entity *e = type->Named.type_name; + GB_ASSERT(e->kind == Entity_TypeName); + String name = e->TypeName.objc_class_name; + + lbAddr *found = string_map_get(&p->module->objc_classes, name); + if (found) { + return lb_addr_load(p, *found); + } else { + lbModule *default_module = &p->module->gen->default_module; + Entity *e = nullptr; + lbAddr default_addr = lb_add_global_generated(default_module, t_objc_Class, {}, &e); + + lbValue ptr = lb_find_value_from_entity(p->module, e); + lbAddr local_addr = lb_addr(ptr); + + string_map_set(&default_module->objc_classes, name, default_addr); + if (default_module != p->module) { + string_map_set(&p->module->objc_classes, name, local_addr); + } + return lb_addr_load(p, local_addr); + } + } + + return lb_build_expr(p, expr); +} + + +lbValue lb_handle_obj_selector(lbProcedure *p, String const &name) { + lbAddr *found = string_map_get(&p->module->objc_selectors, name); + if (found) { + return lb_addr_load(p, *found); + } else { + lbModule *default_module = &p->module->gen->default_module; + Entity *e = nullptr; + lbAddr default_addr = lb_add_global_generated(default_module, t_objc_SEL, {}, &e); + + lbValue ptr = lb_find_value_from_entity(p->module, e); + lbAddr local_addr = lb_addr(ptr); + + string_map_set(&default_module->objc_selectors, name, default_addr); + if (default_module != p->module) { + string_map_set(&p->module->objc_selectors, name, local_addr); + } + return lb_addr_load(p, local_addr); + } +} + + +lbValue lb_handle_obj_send(lbProcedure *p, Ast *expr) { + ast_node(ce, CallExpr, expr); + + lbModule *m = p->module; + CheckerInfo *info = m->info; + ObjcMsgData data = map_must_get(&info->objc_msgSend_types, expr); + GB_ASSERT(data.proc_type != nullptr); + + GB_ASSERT(ce->args.count >= 3); + auto args = array_make(permanent_allocator(), 0, ce->args.count-1); + + lbValue id = lb_handle_obj_id(p, ce->args[1]); + Ast *sel_expr = ce->args[2]; + GB_ASSERT(sel_expr->tav.value.kind == ExactValue_String); + lbValue sel = lb_handle_obj_selector(p, sel_expr->tav.value.value_string); + + array_add(&args, id); + array_add(&args, sel); + for (isize i = 3; i < ce->args.count; i++) { + lbValue arg = lb_build_expr(p, ce->args[i]); + array_add(&args, arg); + } + + + lbValue the_proc = {}; + switch (data.kind) { + default: + GB_PANIC("unhandled ObjcMsgKind %u", data.kind); + break; + case ObjcMsg_normal: the_proc = lb_lookup_runtime_procedure(m, str_lit("objc_msgSend")); break; + case ObjcMsg_fpret: the_proc = lb_lookup_runtime_procedure(m, str_lit("objc_msgSend_fpret")); break; + case ObjcMsg_fp2ret: the_proc = lb_lookup_runtime_procedure(m, str_lit("objc_msgSend_fp2ret")); break; + case ObjcMsg_stret: the_proc = lb_lookup_runtime_procedure(m, str_lit("objc_msgSend_stret")); break; + } + + the_proc = lb_emit_conv(p, the_proc, data.proc_type); + + return lb_emit_call(p, the_proc, args); +} diff --git a/src/types.cpp b/src/types.cpp index 9ee6ba359..cdb31c6e1 100644 --- a/src/types.cpp +++ b/src/types.cpp @@ -685,6 +685,16 @@ gb_global Type *t_map_header = nullptr; gb_global Type *t_equal_proc = nullptr; gb_global Type *t_hasher_proc = nullptr; +gb_global Type *t_objc_object = nullptr; +gb_global Type *t_objc_selector = nullptr; +gb_global Type *t_objc_class = nullptr; + +gb_global Type *t_objc_id = nullptr; +gb_global Type *t_objc_SEL = nullptr; +gb_global Type *t_objc_Class = nullptr; + + + gb_global RecursiveMutex g_type_mutex; struct TypePath; From 05dd3d490de3bf10c56e65987fbbe3024b84a4a6 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 8 Feb 2022 17:33:55 +0000 Subject: [PATCH 02/64] Correct objc_class propagation for parapoly structs --- src/check_type.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/check_type.cpp b/src/check_type.cpp index 6d3e32466..e1a0df7e6 100644 --- a/src/check_type.cpp +++ b/src/check_type.cpp @@ -323,6 +323,8 @@ void add_polymorphic_record_entity(CheckerContext *ctx, Ast *node, Type *named_t } named_type->Named.type_name = e; + GB_ASSERT(original_type->kind == Type_Named); + e->TypeName.objc_class_name = original_type->Named.type_name->TypeName.objc_class_name; mutex_lock(&ctx->info->gen_types_mutex); auto *found_gen_types = map_get(&ctx->info->gen_types, original_type); From c5d348515dcddbd2c29aca79f1863dd36af5476a Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 8 Feb 2022 22:59:37 +0000 Subject: [PATCH 03/64] Add `intrinsics.type_is_subtype_of`; `intrinsics.objc_selector_name` --- src/check_builtin.cpp | 42 +++++++++++++++++++++++++++++---- src/check_expr.cpp | 36 ---------------------------- src/checker_builtin_procs.hpp | 8 +++++-- src/llvm_backend_proc.cpp | 3 +++ src/llvm_backend_utility.cpp | 11 +++++++++ src/types.cpp | 44 +++++++++++++++++++++++++++++++++++ 6 files changed, 101 insertions(+), 43 deletions(-) diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp index 8ada77b12..df22d82e2 100644 --- a/src/check_builtin.cpp +++ b/src/check_builtin.cpp @@ -350,9 +350,15 @@ bool check_builtin_objc_procedure(CheckerContext *c, Operand *operand, Ast *call return true; } break; - case BuiltinProc_objc_create: { - GB_PANIC("TODO: BuiltinProc_objc_create"); - return false; + case BuiltinProc_objc_selector_name: { + String sel_name = {}; + if (!is_constant_string(c, builtin_name, ce->args[0], &sel_name)) { + return false; + } + + operand->type = t_objc_SEL; + operand->mode = Addressing_Value; + return true; } break; } } @@ -392,8 +398,9 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 case BuiltinProc_len: case BuiltinProc_min: case BuiltinProc_max: + case BuiltinProc_type_is_subtype_of: case BuiltinProc_objc_send: - case BuiltinProc_objc_create: + case BuiltinProc_objc_selector_name: // NOTE(bill): The first arg may be a Type, this will be checked case by case break; @@ -435,7 +442,7 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 break; case BuiltinProc_objc_send: - case BuiltinProc_objc_create: + case BuiltinProc_objc_selector_name: return check_builtin_objc_procedure(c, operand, call, id, type_hint); case BuiltinProc___entry_point: @@ -3945,6 +3952,31 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 break; + case BuiltinProc_type_is_subtype_of: + { + Operand op_src = {}; + Operand op_dst = {}; + + check_expr_or_type(c, &op_src, ce->args[0]); + if (op_src.mode != Addressing_Type) { + gbString e = expr_to_string(op_src.expr); + error(op_src.expr, "'%.*s' expects a type, got %s", LIT(builtin_name), e); + gb_string_free(e); + return false; + } + check_expr_or_type(c, &op_dst, ce->args[1]); + if (op_dst.mode != Addressing_Type) { + gbString e = expr_to_string(op_dst.expr); + error(op_dst.expr, "'%.*s' expects a type, got %s", LIT(builtin_name), e); + gb_string_free(e); + return false; + } + + operand->value = exact_value_bool(is_type_subtype_of(op_src.type, op_dst.type)); + operand->mode = Addressing_Constant; + operand->type = t_untyped_bool; + } break; + case BuiltinProc_type_field_index_of: { Operand op = {}; diff --git a/src/check_expr.cpp b/src/check_expr.cpp index 3f31ac810..6db17a316 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -228,42 +228,6 @@ void check_scope_decls(CheckerContext *c, Slice const &nodes, isize reser } } - -isize check_is_assignable_to_using_subtype(Type *src, Type *dst, isize level = 0, bool src_is_ptr = false) { - Type *prev_src = src; - src = type_deref(src); - if (!src_is_ptr) { - src_is_ptr = src != prev_src; - } - src = base_type(src); - - if (!is_type_struct(src)) { - return 0; - } - - for_array(i, src->Struct.fields) { - Entity *f = src->Struct.fields[i]; - if (f->kind != Entity_Variable || (f->flags&EntityFlag_Using) == 0) { - continue; - } - - if (are_types_identical(f->type, dst)) { - return level+1; - } - if (src_is_ptr && is_type_pointer(dst)) { - if (are_types_identical(f->type, type_deref(dst))) { - return level+1; - } - } - isize nested_level = check_is_assignable_to_using_subtype(f->type, dst, level+1, src_is_ptr); - if (nested_level > 0) { - return nested_level; - } - } - - return 0; -} - bool find_or_generate_polymorphic_procedure(CheckerContext *old_c, Entity *base_entity, Type *type, Array *param_operands, Ast *poly_def_node, PolyProcData *poly_proc_data) { /////////////////////////////////////////////////////////////////////////////// diff --git a/src/checker_builtin_procs.hpp b/src/checker_builtin_procs.hpp index 1a9d7d7a0..c14c18412 100644 --- a/src/checker_builtin_procs.hpp +++ b/src/checker_builtin_procs.hpp @@ -241,6 +241,8 @@ BuiltinProc__type_simple_boolean_end, BuiltinProc_type_polymorphic_record_parameter_count, BuiltinProc_type_polymorphic_record_parameter_value, + BuiltinProc_type_is_subtype_of, + BuiltinProc_type_field_index_of, BuiltinProc_type_equal_proc, @@ -251,7 +253,7 @@ BuiltinProc__type_end, BuiltinProc___entry_point, BuiltinProc_objc_send, - BuiltinProc_objc_create, + BuiltinProc_objc_selector_name, BuiltinProc_COUNT, }; @@ -494,6 +496,8 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = { {STR_LIT("type_polymorphic_record_parameter_count"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, {STR_LIT("type_polymorphic_record_parameter_value"), 2, false, Expr_Expr, BuiltinProcPkg_intrinsics}, + {STR_LIT("type_is_subtype_of"), 2, false, Expr_Expr, BuiltinProcPkg_intrinsics}, + {STR_LIT("type_field_index_of"), 2, false, Expr_Expr, BuiltinProcPkg_intrinsics}, {STR_LIT("type_equal_proc"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, @@ -505,5 +509,5 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = { {STR_LIT("__entry_point"), 0, false, Expr_Stmt, BuiltinProcPkg_intrinsics}, {STR_LIT("objc_send"), 3, true, Expr_Expr, BuiltinProcPkg_intrinsics}, - {STR_LIT("objc_create"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, + {STR_LIT("objc_selector_name"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, }; diff --git a/src/llvm_backend_proc.cpp b/src/llvm_backend_proc.cpp index 6de0aaed7..caa3dfa1a 100644 --- a/src/llvm_backend_proc.cpp +++ b/src/llvm_backend_proc.cpp @@ -2109,6 +2109,9 @@ lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValue const &tv, case BuiltinProc_objc_send: return lb_handle_obj_send(p, expr); + + case BuiltinProc_objc_selector_name: + return lb_handle_obj_selector_name(p, expr); } GB_PANIC("Unhandled built-in procedure %.*s", LIT(builtin_procs[id].name)); diff --git a/src/llvm_backend_utility.cpp b/src/llvm_backend_utility.cpp index d92f711ba..8ef66df7a 100644 --- a/src/llvm_backend_utility.cpp +++ b/src/llvm_backend_utility.cpp @@ -1915,3 +1915,14 @@ lbValue lb_handle_obj_send(lbProcedure *p, Ast *expr) { return lb_emit_call(p, the_proc, args); } + + +lbValue lb_handle_obj_selector_name(lbProcedure *p, Ast *expr) { + ast_node(ce, CallExpr, expr); + + auto tav = ce->args[0]->tav; + GB_ASSERT(tav.value.kind == ExactValue_String); + String name = tav.value.value_string; + return lb_handle_obj_selector(p, name); + +} \ No newline at end of file diff --git a/src/types.cpp b/src/types.cpp index cdb31c6e1..024d644a2 100644 --- a/src/types.cpp +++ b/src/types.cpp @@ -3748,6 +3748,50 @@ i64 type_offset_of_from_selection(Type *type, Selection sel) { return offset; } +isize check_is_assignable_to_using_subtype(Type *src, Type *dst, isize level = 0, bool src_is_ptr = false) { + Type *prev_src = src; + src = type_deref(src); + if (!src_is_ptr) { + src_is_ptr = src != prev_src; + } + src = base_type(src); + + if (!is_type_struct(src)) { + return 0; + } + + for_array(i, src->Struct.fields) { + Entity *f = src->Struct.fields[i]; + if (f->kind != Entity_Variable || (f->flags&EntityFlag_Using) == 0) { + continue; + } + + if (are_types_identical(f->type, dst)) { + return level+1; + } + if (src_is_ptr && is_type_pointer(dst)) { + if (are_types_identical(f->type, type_deref(dst))) { + return level+1; + } + } + isize nested_level = check_is_assignable_to_using_subtype(f->type, dst, level+1, src_is_ptr); + if (nested_level > 0) { + return nested_level; + } + } + + return 0; +} + +bool is_type_subtype_of(Type *src, Type *dst) { + if (are_types_identical(src, dst)) { + return true; + } + + return 0 < check_is_assignable_to_using_subtype(src, dst, 0, is_type_pointer(src)); +} + + Type *get_struct_field_type(Type *t, isize index) { t = base_type(type_deref(t)); From 340838c8789385212eb3225c15cabbd38b51dbea Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 8 Feb 2022 23:00:00 +0000 Subject: [PATCH 04/64] Add procs_darwin.odin --- core/runtime/procs_darwin.odin | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 core/runtime/procs_darwin.odin diff --git a/core/runtime/procs_darwin.odin b/core/runtime/procs_darwin.odin new file mode 100644 index 000000000..79fd777d7 --- /dev/null +++ b/core/runtime/procs_darwin.odin @@ -0,0 +1,20 @@ +//+private +package runtime + +foreign import "system:Foundation.framework" + +import "core:intrinsics" + +objc_id :: ^intrinsics.objc_object +objc_Class :: ^intrinsics.objc_class +objc_SEL :: ^intrinsics.objc_selector + +foreign Foundation { + objc_lookUpClass :: proc "c" (name: cstring) -> objc_Class --- + sel_registerName :: proc "c" (name: cstring) -> objc_SEL --- + + objc_msgSend :: proc "c" (self: objc_id, op: objc_SEL, #c_vararg args: ..any) --- + objc_msgSend_fpret :: proc "c" (self: objc_id, op: objc_SEL, #c_vararg args: ..any) -> f64 --- + objc_msgSend_fp2ret :: proc "c" (self: objc_id, op: objc_SEL, #c_vararg args: ..any) -> complex128 --- + objc_msgSend_stret :: proc "c" (self: objc_id, op: objc_SEL, #c_vararg args: ..any) --- +} From b95ade40c075ed23525f28d571b0175040194ed2 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Wed, 9 Feb 2022 00:19:20 +0000 Subject: [PATCH 05/64] Begin work on `core:sys/darwin/Foundation` --- core/sys/darwin/Foundation/Foundation.odin | 1 + core/sys/darwin/Foundation/NSArray.odin | 26 ++++ .../darwin/Foundation/NSAutoreleasePool.odin | 15 +++ core/sys/darwin/Foundation/NSData.odin | 12 ++ core/sys/darwin/Foundation/NSDate.odin | 8 ++ core/sys/darwin/Foundation/NSDictionary.odin | 27 +++++ core/sys/darwin/Foundation/NSLock.odin | 29 +++++ .../sys/darwin/Foundation/NSNotification.odin | 16 +++ core/sys/darwin/Foundation/NSNumber.odin | 45 +++++++ core/sys/darwin/Foundation/NSObject.odin | 66 +++++++++++ core/sys/darwin/Foundation/NSRange.odin | 22 ++++ core/sys/darwin/Foundation/NSString.odin | 112 ++++++++++++++++++ core/sys/darwin/Foundation/NSTypes.odin | 35 ++++++ 13 files changed, 414 insertions(+) create mode 100644 core/sys/darwin/Foundation/Foundation.odin create mode 100644 core/sys/darwin/Foundation/NSArray.odin create mode 100644 core/sys/darwin/Foundation/NSAutoreleasePool.odin create mode 100644 core/sys/darwin/Foundation/NSData.odin create mode 100644 core/sys/darwin/Foundation/NSDate.odin create mode 100644 core/sys/darwin/Foundation/NSDictionary.odin create mode 100644 core/sys/darwin/Foundation/NSLock.odin create mode 100644 core/sys/darwin/Foundation/NSNotification.odin create mode 100644 core/sys/darwin/Foundation/NSNumber.odin create mode 100644 core/sys/darwin/Foundation/NSObject.odin create mode 100644 core/sys/darwin/Foundation/NSRange.odin create mode 100644 core/sys/darwin/Foundation/NSString.odin create mode 100644 core/sys/darwin/Foundation/NSTypes.odin diff --git a/core/sys/darwin/Foundation/Foundation.odin b/core/sys/darwin/Foundation/Foundation.odin new file mode 100644 index 000000000..c69b10ddb --- /dev/null +++ b/core/sys/darwin/Foundation/Foundation.odin @@ -0,0 +1 @@ +package objc_Foundation diff --git a/core/sys/darwin/Foundation/NSArray.odin b/core/sys/darwin/Foundation/NSArray.odin new file mode 100644 index 000000000..7544c278c --- /dev/null +++ b/core/sys/darwin/Foundation/NSArray.odin @@ -0,0 +1,26 @@ +package objc_Foundation + +import "core:intrinsics" + +@(objc_class="NSArray") +Array :: struct($T: typeid) where intrinsics.type_is_pointer(T), intrinsics.type_is_subtype_of(T, ^Object) {using _: Copying(Array(T))} + +Array_initWithObjects :: proc(self: ^$A/Array($T), objects: [^]^Object, count: UInteger) -> ^A { + return msgSend(^A, "initWithObjects:count:", objects, count) +} + +Array_initWithCoder :: proc(self: ^$A/Array($T), coder: ^Coder) -> ^A { + return msgSend(^A, "initWithCoder:", coder) +} + +Array_objectAtIndex :: proc(self: ^Array($T), index: UInteger) -> ^Object { + return msgSend(^Object, self, "objectAtIndex:", index) +} + +Array_object :: proc(self: ^Array($T), index: UInteger) -> ^T { + return (^T)(Array_objectAtIndex(self, index)) +} + +Array_count :: proc(self: ^Array($T)) -> UInteger { + return msgSend(UInteger, self, "count") +} diff --git a/core/sys/darwin/Foundation/NSAutoreleasePool.odin b/core/sys/darwin/Foundation/NSAutoreleasePool.odin new file mode 100644 index 000000000..5ff2a6f1d --- /dev/null +++ b/core/sys/darwin/Foundation/NSAutoreleasePool.odin @@ -0,0 +1,15 @@ +package objc_Foundation + +@(objc_class="NSAutoreleasePool") +AutoreleasePool :: struct {using _: Object} + +AutoreleasePool_drain :: proc(self: ^AutoreleasePool) { + msgSend(nil, self, "drain") +} +AutoreleasePool_addObject :: proc(self: ^AutoreleasePool, obj: ^Object) { + msgSend(nil, self, "addObject:", obj) +} +AutoreleasePool_showPools :: proc(self: ^AutoreleasePool, obj: ^Object) { + msgSend(nil, self, "showPools") +} + diff --git a/core/sys/darwin/Foundation/NSData.odin b/core/sys/darwin/Foundation/NSData.odin new file mode 100644 index 000000000..93bb3ae0e --- /dev/null +++ b/core/sys/darwin/Foundation/NSData.odin @@ -0,0 +1,12 @@ +package objc_Foundation + +@(objc_class="NSData") +Data :: struct {using _: Copying(Data)} + +Data_mutableBytes :: proc(self: ^Data) -> rawptr { + return msgSend(rawptr, self, "mutableBytes") +} + +Data_length :: proc(self: ^Data) -> UInteger { + return msgSend(UInteger, self, "length") +} \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSDate.odin b/core/sys/darwin/Foundation/NSDate.odin new file mode 100644 index 000000000..4b298ee24 --- /dev/null +++ b/core/sys/darwin/Foundation/NSDate.odin @@ -0,0 +1,8 @@ +package objc_Foundation + +@(objc_class="NSDate") +Date :: struct {using _: Copying(Date)} + +Date_dateWithTimeIntervalSinceNow :: proc(secs: TimeInterval) -> ^Date { + return msgSend(^Date, Date, "dateWithTimeIntervalSinceNow:", secs) +} \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSDictionary.odin b/core/sys/darwin/Foundation/NSDictionary.odin new file mode 100644 index 000000000..19ea8a491 --- /dev/null +++ b/core/sys/darwin/Foundation/NSDictionary.odin @@ -0,0 +1,27 @@ +package objc_Foundation + +@(objc_class="NSDictionary") +Dictionary :: struct {using _: Copying(Dictionary)} + +Dictionary_dictionary :: proc() -> ^Dictionary { + return msgSend(^Dictionary, Dictionary, "dictionary") +} + +Dictionary_dictionaryWithObject :: proc(object: ^Object, forKey: ^Object) -> ^Dictionary { + return msgSend(^Dictionary, Dictionary, "dictionaryWithObject:forKey:", object, forKey) +} + +Dictionary_dictionaryWithObjects :: proc(objects: [^]^Object, forKeys: [^]^Object, count: UInteger) -> ^Dictionary { + return msgSend(^Dictionary, Dictionary, "dictionaryWithObjects:forKeys:count", objects, forKeys, count) +} + + +Dictionary_initWithObjects :: proc(self: ^Dictionary, objects: [^]^Object, forKeys: [^]^Object, count: UInteger) -> ^Dictionary { + return msgSend(^Dictionary, self, "initWithObjects:forKeys:count", objects, forKeys, count) +} + +Dictionary_objectForKey :: proc(self: ^Dictionary, key: ^Object) -> ^Object { + return msgSend(^Dictionary, self, "objectForKey:", key) +} + +// TODO(bill): enumerator \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSLock.odin b/core/sys/darwin/Foundation/NSLock.odin new file mode 100644 index 000000000..0e76dfc62 --- /dev/null +++ b/core/sys/darwin/Foundation/NSLock.odin @@ -0,0 +1,29 @@ +package objc_Foundation + +Locking :: struct($T: typeid) {using _: Object} + +Locking_lock :: proc(self: ^Locking($T)) { + msgSend(nil, self, "lock") +} +Locking_unlock :: proc(self: ^Locking($T)) { + msgSend(nil, self, "unlock") +} + +@(objc_class="NSCondition") +Condition :: struct {using _: Locking(Condition) } + +Condition_wait :: proc(self: ^Condition) { + msgSend(nil, self, "wait") +} + +Condition_waitUntilDate :: proc(self: ^Condition, limit: ^Date) -> BOOL { + return msgSend(BOOL, self, "waitUntilDate:", limit) +} + +Condition_signal :: proc(self: ^Condition) { + msgSend(nil, self, "signal") +} + +Condition_broadcast :: proc(self: ^Condition) { + msgSend(nil, self, "broadcast") +} \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSNotification.odin b/core/sys/darwin/Foundation/NSNotification.odin new file mode 100644 index 000000000..fa9160cc8 --- /dev/null +++ b/core/sys/darwin/Foundation/NSNotification.odin @@ -0,0 +1,16 @@ +package objc_Foundation + +@(objc_class="NSNotification") +Notification :: struct{using _: Object} + +Notification_name :: proc(self: ^Notification) -> ^String { + return msgSend(^String, self, "name") +} + +Notification_object :: proc(self: ^Notification) -> ^Object { + return msgSend(^Object, self, "object") +} + +Notification_userInfo :: proc(self: ^Notification) -> ^Dictionary { + return msgSend(^Dictionary, self, "userInfo") +} \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSNumber.odin b/core/sys/darwin/Foundation/NSNumber.odin new file mode 100644 index 000000000..d41f1e6d2 --- /dev/null +++ b/core/sys/darwin/Foundation/NSNumber.odin @@ -0,0 +1,45 @@ +package objc_Foundation + +@(objc_class="NSValue") +Value :: struct{using _: Copying(Value)} + + +@(objc_class="NSNumber") +Number :: struct{using _: Copying(Number), using _: Value} + + +Value_valueWithBytes :: proc(value: rawptr, type: cstring) -> ^Value { + return msgSend(^Value, Value, "valueWithBytes:objCType:", value, type) +} + +Value_valueWithPointer :: proc(pointer: rawptr) -> ^Value { + return msgSend(^Value, Value, "valueWithPointer:", pointer) +} + +Value_initWithBytes :: proc(value: rawptr, type: cstring) -> ^Value { + return msgSend(^Value, Value, "initWithBytes:objCType:", value, type) +} + +Value_initWithCoder :: proc(coder: ^Coder) -> ^Value { + return msgSend(^Value, Value, "initWithCoder:", coder) +} + +Value_getValue :: proc(self: ^Value, value: rawptr, size: UInteger) { + msgSend(nil, self, "getValue:size:", value, size) +} + + +Value_objCType :: proc(self: ^Value) -> cstring { + return msgSend(cstring, self, "objCType") +} + +Value_isEqualToValue :: proc(self, other: ^Value) -> BOOL { + return msgSend(BOOL, self, "isEqualToValue:", other) +} + +Value_pointerValue :: proc(self: ^Value) -> rawptr { + return msgSend(rawptr, self, "pointerValue") +} + + +// TODO(bill): Number methods \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSObject.odin b/core/sys/darwin/Foundation/NSObject.odin new file mode 100644 index 000000000..cf15dd68d --- /dev/null +++ b/core/sys/darwin/Foundation/NSObject.odin @@ -0,0 +1,66 @@ +package objc_Foundation + +import "core:intrinsics" + +methodSignatureForSelector :: proc "c" (obj: ^Object, selector: SEL) -> rawptr { + return msgSend(rawptr, obj, "methodSignatureForSelector:", selector) +} + +respondsToSelector :: proc "c" (obj: ^Object, selector: SEL) -> BOOL { + return msgSend(BOOL, obj, "respondsToSelector:", selector) +} + +msgSendSafeCheck :: proc "c" (obj: ^Object, selector: SEL) -> BOOL { + return respondsToSelector(obj, selector) || methodSignatureForSelector(obj, selector) != nil +} + + +@(objc_class="NSObject") +Object :: struct {using _: intrinsics.objc_object} + +@(objc_class="NSObject") +Copying :: struct($T: typeid) {using _: Object} + +alloc :: proc($T: typeid) -> ^T where intrinsics.type_is_subtype_of(T, Object) { + return msgSend(^T, T, "alloc") +} +init :: proc(self: ^$T) -> ^T where intrinsics.type_is_subtype_of(T, Object){ + return msgSend(^T, self, "init") +} +retain :: proc(self: ^$T) -> ^T where intrinsics.type_is_subtype_of(T, Object) { + return msgSend(^T, self, "retain") +} +release :: proc(self: ^$T) where intrinsics.type_is_subtype_of(T, Object) { + msgSend(nil, self, "release") +} +retainCount :: proc(self: ^$T) -> UInteger where intrinsics.type_is_subtype_of(T, Object) { + return msgSend(UInteger, self, "retainCount") +} + +copy :: proc(self: ^Copying($T)) -> ^T where intrinsics.type_is_subtype_of(T, Object) { + return msgSend(^T, self, "copy") +} + +hash :: proc(self: ^Object) -> UInteger { + return msgSend(UInteger, self, "hash") +} + +isEqual :: proc(self, pObject: ^Object) -> BOOL { + return msgSend(BOOL, self, "isEqual:", pObject) +} + +description :: proc(self: ^Object) -> ^String { + return msgSend(^String, self, "description") +} + +debugDescription :: proc(self: ^Object) -> ^String { + if msgSendSafeCheck(self, intrinsics.objc_selector_name("debugDescription")) { + return msgSend(^String, self, "debugDescription") + } + return nil +} + + +@(objc_class="NSCoder") +Coder :: struct {using _: Object} +// TODO(bill): Implement all the methods for this massive type \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSRange.odin b/core/sys/darwin/Foundation/NSRange.odin new file mode 100644 index 000000000..74ce595a3 --- /dev/null +++ b/core/sys/darwin/Foundation/NSRange.odin @@ -0,0 +1,22 @@ +package objc_Foundation + +Range :: struct { + location: UInteger, + length: UInteger, +} + +Range_Make :: proc(loc, len: UInteger) -> Range { + return Range{loc, len} +} + +Range_Equal :: proc(a, b: Range) -> BOOL { + return a == b +} + +Range_LocationInRange :: proc(self: Range, loc: UInteger) -> BOOL { + return !((loc < self.location) && ((loc - self.location) < self.length)) +} + +Range_Max :: proc(self: Range) -> UInteger { + return self.location + self.length +} \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSString.odin b/core/sys/darwin/Foundation/NSString.odin new file mode 100644 index 000000000..857e27f12 --- /dev/null +++ b/core/sys/darwin/Foundation/NSString.odin @@ -0,0 +1,112 @@ +package objc_Foundation + +foreign import "system:Foundation.framework" + +@(objc_class="NSString") +String :: struct {using _: Copying(String)} + +StringEncoding :: enum UInteger { + ASCII = 1, + NEXTSTEP = 2, + JapaneseEUC = 3, + UTF8 = 4, + ISOLatin1 = 5, + Symbol = 6, + NonLossyASCII = 7, + ShiftJIS = 8, + ISOLatin2 = 9, + Unicode = 10, + WindowsCP1251 = 11, + WindowsCP1252 = 12, + WindowsCP1253 = 13, + WindowsCP1254 = 14, + WindowsCP1250 = 15, + ISO2022JP = 21, + MacOSRoman = 30, + + UTF16 = Unicode, + + UTF16BigEndian = 0x90000100, + UTF16LittleEndian = 0x94000100, + + UTF32 = 0x8c000100, + UTF32BigEndian = 0x98000100, + UTF32LittleEndian = 0x9c000100, +} + +StringCompareOptions :: distinct bit_set[StringCompareOption; UInteger] +StringCompareOption :: enum UInteger { + CaseInsensitive = 0, + LiteralSearch = 1, + BackwardsSearch = 2, + AnchoredSearch = 3, + NumericSearch = 6, + DiacriticInsensitive = 7, + WidthInsensitive = 8, + ForcedOrdering = 9, + RegularExpression = 10, +} + +unichar :: distinct u16 + +foreign Foundation { + __CFStringMakeConstantString :: proc "c" (c: cstring) -> ^String --- +} + +AT :: MakeConstantString +MakeConstantString :: proc "c" (#const c: cstring) -> ^String { + return __CFStringMakeConstantString(c) +} + + +String_initWithString :: proc(self: ^String, other: ^String) -> ^String { + return msgSend(^String, self, "initWithString:", other) +} + +String_initWithCString :: proc(self: ^String, pString: cstring, encoding: StringEncoding) -> ^String { + return msgSend(^String, self, "initWithCstring:encoding:", pString, encoding) +} + +String_initWithBytesNoCopy :: proc(self: ^String, pBytes: rawptr, length: UInteger, encoding: StringEncoding, freeWhenDone: bool) -> ^String { + return msgSend(^String, self, "initWithBytesNoCopy:length:encoding:freeWhenDone:", pBytes, length, encoding, freeWhenDone) +} + +String_initWithOdinString :: proc(self: ^String, str: string) -> ^String { + return String_initWithBytesNoCopy(self, raw_data(str), UInteger(len(str)), .UTF8, false) +} + +String_characterAtIndex :: proc(self: ^String, index: UInteger) -> unichar { + return msgSend(unichar, self, "characterAtIndex:", index) +} + +String_length :: proc(self: ^String) -> UInteger { + return msgSend(UInteger, self, "length") +} + +String_cStringUsingEncoding :: proc(self: ^String, encoding: StringEncoding) -> cstring { + return msgSend(cstring, self, "cStringUsingEncoding:", encoding) +} + +String_UTFString :: proc(self: ^String) -> cstring { + return msgSend(cstring, self, "UTFString") +} + +String_OdinString :: proc(self: ^String) -> string { + return string(String_UTFString(self)) +} + +String_maximumLengthOfBytesUsingEncoding :: proc(self: ^String, encoding: StringEncoding) -> UInteger { + return msgSend(UInteger, self, "maximumLengthOfBytesUsingEncoding:", encoding) +} + +String_lengthOfBytesUsingEncoding :: proc(self: ^String, encoding: StringEncoding) -> UInteger { + return msgSend(UInteger, self, "lengthOfBytesUsingEncoding:", encoding) +} + +String_isEqualToString :: proc(self, other: ^String) -> BOOL { + return msgSend(BOOL, self, "isEqualToString:", other) +} + +String_rangeOfString :: proc(self, other: ^String, options: StringCompareOptions) -> Range { + return msgSend(Range, self, "rangeOfString:options:", other, options) +} \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSTypes.odin b/core/sys/darwin/Foundation/NSTypes.odin new file mode 100644 index 000000000..47f75630f --- /dev/null +++ b/core/sys/darwin/Foundation/NSTypes.odin @@ -0,0 +1,35 @@ +package objc_Foundation + +import "core:intrinsics" + +@(private) msgSend :: intrinsics.objc_send + +id :: ^intrinsics.objc_object +SEL :: ^intrinsics.objc_selector +Class :: ^intrinsics.objc_class + +TimeInterval :: distinct f64 +Integer :: distinct int +UInteger :: distinct uint + +IntegerMax :: max(Integer) +Integermin :: min(Integer) +UIntegerMax :: max(UInteger) + +BOOL :: bool // TODO(bill): should this be `distinct`? +YES :: true +NO :: false + +OperatingSystemVersion :: struct #packed { + majorVersion: Integer, + minorVersion: Integer, + patchVersion: Integer, +} + +ComparisonResult :: enum Integer { + OrderedAscending = -1, + OrderedSame = 0, + OrderedDescending = 1, +} + +NotFound :: IntegerMax From 5f2514db635a94937d214be4c4af16eaf8a5dcde Mon Sep 17 00:00:00 2001 From: gingerBill Date: Wed, 9 Feb 2022 11:50:11 +0000 Subject: [PATCH 06/64] Add NSNumber and NSURL --- core/sys/darwin/Foundation/NSArray.odin | 4 +- core/sys/darwin/Foundation/NSNumber.odin | 104 +++++++++++++++++++++-- core/sys/darwin/Foundation/NSURL.odin | 15 ++++ 3 files changed, 116 insertions(+), 7 deletions(-) create mode 100644 core/sys/darwin/Foundation/NSURL.odin diff --git a/core/sys/darwin/Foundation/NSArray.odin b/core/sys/darwin/Foundation/NSArray.odin index 7544c278c..a58543d7a 100644 --- a/core/sys/darwin/Foundation/NSArray.odin +++ b/core/sys/darwin/Foundation/NSArray.odin @@ -3,7 +3,9 @@ package objc_Foundation import "core:intrinsics" @(objc_class="NSArray") -Array :: struct($T: typeid) where intrinsics.type_is_pointer(T), intrinsics.type_is_subtype_of(T, ^Object) {using _: Copying(Array(T))} +Array :: struct($T: typeid) where intrinsics.type_is_pointer(T), intrinsics.type_is_subtype_of(T, ^Object) { + using _: Copying(Array(T)), +} Array_initWithObjects :: proc(self: ^$A/Array($T), objects: [^]^Object, count: UInteger) -> ^A { return msgSend(^A, "initWithObjects:count:", objects, count) diff --git a/core/sys/darwin/Foundation/NSNumber.odin b/core/sys/darwin/Foundation/NSNumber.odin index d41f1e6d2..3b8e59419 100644 --- a/core/sys/darwin/Foundation/NSNumber.odin +++ b/core/sys/darwin/Foundation/NSNumber.odin @@ -1,13 +1,13 @@ package objc_Foundation +import "core:c" + +#assert(size_of(c.long) == size_of(int)) +#assert(size_of(c.ulong) == size_of(uint)) + @(objc_class="NSValue") Value :: struct{using _: Copying(Value)} - -@(objc_class="NSNumber") -Number :: struct{using _: Copying(Number), using _: Value} - - Value_valueWithBytes :: proc(value: rawptr, type: cstring) -> ^Value { return msgSend(^Value, Value, "valueWithBytes:objCType:", value, type) } @@ -42,4 +42,96 @@ Value_pointerValue :: proc(self: ^Value) -> rawptr { } -// TODO(bill): Number methods \ No newline at end of file +@(objc_class="NSNumber") +Number :: struct{using _: Copying(Number), using _: Value} + + +Number_numberWithI8 :: proc(value: i8) -> ^Number { return msgSend(^Number, Number, "numberWithChar:", value) } +Number_numberWithU8 :: proc(value: u8) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedChar:", value) } +Number_numberWithI16 :: proc(value: i16) -> ^Number { return msgSend(^Number, Number, "numberWithShort:", value) } +Number_numberWithU16 :: proc(value: u16) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedShort:", value) } +Number_numberWithI32 :: proc(value: i32) -> ^Number { return msgSend(^Number, Number, "numberWithInt:", value) } +Number_numberWithU32 :: proc(value: u32) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedInt:", value) } +Number_numberWithInt :: proc(value: int) -> ^Number { return msgSend(^Number, Number, "numberWithLong:", value) } +Number_numberWithUint :: proc(value: uint) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLong:", value) } +Number_numberWithU64 :: proc(value: u64) -> ^Number { return msgSend(^Number, Number, "numberWithLongLong:", value) } +Number_numberWithI64 :: proc(value: i64) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLongLong:", value) } +Number_numberWithF32 :: proc(value: f32) -> ^Number { return msgSend(^Number, Number, "numberWithFloat:", value) } +Number_numberWithF64 :: proc(value: f64) -> ^Number { return msgSend(^Number, Number, "numberWithDouble:", value) } +Number_numberWithBool :: proc(value: BOOL) -> ^Number { return msgSend(^Number, Number, "numberWithBool:", value) } + +Number_number :: proc{ + Number_numberWithI8, + Number_numberWithU8, + Number_numberWithI16, + Number_numberWithU16, + Number_numberWithI32, + Number_numberWithU32, + Number_numberWithInt, + Number_numberWithUint, + Number_numberWithU64, + Number_numberWithI64, + Number_numberWithF32, + Number_numberWithF64, + Number_numberWithBool, +} + +Number_initWithI8 :: proc(self: ^Number, value: i8) -> ^Number { return msgSend(^Number, self, "initWithChar:", value) } +Number_initWithU8 :: proc(self: ^Number, value: u8) -> ^Number { return msgSend(^Number, self, "initWithUnsignedChar:", value) } +Number_initWithI16 :: proc(self: ^Number, value: i16) -> ^Number { return msgSend(^Number, self, "initWithShort:", value) } +Number_initWithU16 :: proc(self: ^Number, value: u16) -> ^Number { return msgSend(^Number, self, "initWithUnsignedShort:", value) } +Number_initWithI32 :: proc(self: ^Number, value: i32) -> ^Number { return msgSend(^Number, self, "initWithInt:", value) } +Number_initWithU32 :: proc(self: ^Number, value: u32) -> ^Number { return msgSend(^Number, self, "initWithUnsignedInt:", value) } +Number_initWithInt :: proc(self: ^Number, value: int) -> ^Number { return msgSend(^Number, self, "initWithLong:", value) } +Number_initWithUint :: proc(self: ^Number, value: uint) -> ^Number { return msgSend(^Number, self, "initWithUnsignedLong:", value) } +Number_initWithU64 :: proc(self: ^Number, value: u64) -> ^Number { return msgSend(^Number, self, "initWithLongLong:", value) } +Number_initWithI64 :: proc(self: ^Number, value: i64) -> ^Number { return msgSend(^Number, self, "initWithUnsignedLongLong:", value) } +Number_initWithF32 :: proc(self: ^Number, value: f32) -> ^Number { return msgSend(^Number, self, "initWithFloat:", value) } +Number_initWithF64 :: proc(self: ^Number, value: f64) -> ^Number { return msgSend(^Number, self, "initWithDouble:", value) } +Number_initWithBool :: proc(self: ^Number, value: BOOL) -> ^Number { return msgSend(^Number, self, "initWithBool:", value) } + + +Number_init :: proc{ + Number_initWithI8, + Number_initWithU8, + Number_initWithI16, + Number_initWithU16, + Number_initWithI32, + Number_initWithU32, + Number_initWithInt, + Number_initWithUint, + Number_initWithU64, + Number_initWithI64, + Number_initWithF32, + Number_initWithF64, + Number_initWithBool, +} + +Number_i8Value :: proc(self: ^Number) -> i8 { return msgSend(i8, self, "charValue") } +Number_u8Value :: proc(self: ^Number) -> u8 { return msgSend(u8, self, "unsignedCharValue") } +Number_i16Value :: proc(self: ^Number) -> i16 { return msgSend(i16, self, "shortValue") } +Number_u16Value :: proc(self: ^Number) -> u16 { return msgSend(u16, self, "unsignedShortValue") } +Number_i32Value :: proc(self: ^Number) -> i32 { return msgSend(i32, self, "intValue") } +Number_u32Value :: proc(self: ^Number) -> u32 { return msgSend(u32, self, "unsignedIntValue") } +Number_intValue :: proc(self: ^Number) -> int { return msgSend(int, self, "longValue") } +Number_uintValue :: proc(self: ^Number) -> uint { return msgSend(uint, self, "unsignedLongValue") } +Number_u64Value :: proc(self: ^Number) -> u64 { return msgSend(u64, self, "longLongValue") } +Number_i64Value :: proc(self: ^Number) -> i64 { return msgSend(i64, self, "unsignedLongLongValue") } +Number_f32Value :: proc(self: ^Number) -> f32 { return msgSend(f32, self, "floatValue") } +Number_f64Value :: proc(self: ^Number) -> f64 { return msgSend(f64, self, "doubleValue") } +Number_boolValue :: proc(self: ^Number) -> BOOL { return msgSend(BOOL, self, "boolValue") } +Number_integerValue :: proc(self: ^Number) -> Integer { return msgSend(Integer, self, "integerValue") } +Number_uintegerValue :: proc(self: ^Number) -> UInteger { return msgSend(UInteger, self, "unsignedIntegerValue") } +Number_stringValue :: proc(self: ^Number) -> ^String { return msgSend(^String, self, "stringValue") } + +Number_compare :: proc(a, b: ^Number) -> ComparisonResult { + return msgSend(ComparisonResult, a, "compare:", b) +} + +Number_isEqualToNumber :: proc(a, b: ^Number) -> BOOL { + return msgSend(BOOL, a, "isEqualToNumber:", b) +} + +Number_descriptionWithLocale :: proc(self: ^Number, locale: ^Object) -> ^String { + return msgSend(^String, self, "descriptionWithLocale:", locale) +} \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSURL.odin b/core/sys/darwin/Foundation/NSURL.odin new file mode 100644 index 000000000..f4f776130 --- /dev/null +++ b/core/sys/darwin/Foundation/NSURL.odin @@ -0,0 +1,15 @@ +package objc_Foundation + +@(objc_class="NSURL") +URL :: struct{using _: Copying(URL)} + +URL_initWithString :: proc(self: ^URL, value: ^String) -> ^URL { + return msgSend(^URL, self, "initWithString:", value) +} +URL_initFileURLWithPath :: proc(self: ^URL, path: ^String) -> ^URL { + return msgSend(^URL, self, "initFileURLWithPath:", path) +} + +URL_fileSystemRepresentation :: proc(self: ^URL) -> ^String { + return msgSend(^String, self, "fileSystemRepresentation") +} \ No newline at end of file From 768c2684d01ac77c7e15d4a24a48f21a8fbc8abc Mon Sep 17 00:00:00 2001 From: gingerBill Date: Wed, 9 Feb 2022 12:19:59 +0000 Subject: [PATCH 07/64] Add NSBundle, NSError, NSEnumerator --- core/sys/darwin/Foundation/NSArray.odin | 4 +- core/sys/darwin/Foundation/NSBundle.odin | 161 +++++++++++++++++++ core/sys/darwin/Foundation/NSDictionary.odin | 8 +- core/sys/darwin/Foundation/NSEnumerator.odin | 37 +++++ core/sys/darwin/Foundation/NSError.odin | 68 ++++++++ 5 files changed, 275 insertions(+), 3 deletions(-) create mode 100644 core/sys/darwin/Foundation/NSBundle.odin create mode 100644 core/sys/darwin/Foundation/NSEnumerator.odin create mode 100644 core/sys/darwin/Foundation/NSError.odin diff --git a/core/sys/darwin/Foundation/NSArray.odin b/core/sys/darwin/Foundation/NSArray.odin index a58543d7a..435e239a2 100644 --- a/core/sys/darwin/Foundation/NSArray.odin +++ b/core/sys/darwin/Foundation/NSArray.odin @@ -19,8 +19,8 @@ Array_objectAtIndex :: proc(self: ^Array($T), index: UInteger) -> ^Object { return msgSend(^Object, self, "objectAtIndex:", index) } -Array_object :: proc(self: ^Array($T), index: UInteger) -> ^T { - return (^T)(Array_objectAtIndex(self, index)) +Array_object :: proc(self: ^Array($T), index: UInteger) -> T { + return (T)(Array_objectAtIndex(self, index)) } Array_count :: proc(self: ^Array($T)) -> UInteger { diff --git a/core/sys/darwin/Foundation/NSBundle.odin b/core/sys/darwin/Foundation/NSBundle.odin new file mode 100644 index 000000000..375e15b65 --- /dev/null +++ b/core/sys/darwin/Foundation/NSBundle.odin @@ -0,0 +1,161 @@ +package objc_Foundation + +@(objc_class="NSBundle") +Bundle :: struct { using _: Object } + +Bundle_mainBundle :: proc() -> ^Bundle { + return msgSend(^Bundle, Bundle, "mainBundle") +} + +Bundle_bundleWithPath :: proc(path: ^String) -> ^Bundle { + return msgSend(^Bundle, Bundle, "bundleWithPath:", path) +} + +Bundle_bundleWithURL :: proc(url: ^URL) -> ^Bundle { + return msgSend(^Bundle, Bundle, "bundleWithUrl:", url) +} +Bundle_bundle :: proc{ + Bundle_bundleWithPath, + Bundle_bundleWithURL, +} + + +Bundle_initWithPath :: proc(self: ^Bundle, path: ^String) -> ^Bundle { + return msgSend(^Bundle, self, "initWithPath:", path) +} + +Bundle_initWithURL :: proc(self: ^Bundle, url: ^URL) -> ^Bundle { + return msgSend(^Bundle, self, "initWithUrl:", url) +} +Bundle_init :: proc{ + Bundle_initWithPath, + Bundle_initWithURL, +} + + +Bundle_allBundles :: proc() -> (all: ^Array(^Bundle)) { + return msgSend(type_of(all), Bundle, "allBundles") +} + +Bundle_allFrameworks :: proc() -> (all: ^Array(^Object)) { + return msgSend(type_of(all), Bundle, "allFrameworks") +} + +Bundle_load :: proc(self: ^Bundle) -> BOOL { + return msgSend(BOOL, self, "load") +} +Bundle_unload :: proc(self: ^Bundle) -> BOOL { + return msgSend(BOOL, self, "unload") +} + +Bundle_isLoaded :: proc(self: ^Bundle) -> BOOL { + return msgSend(BOOL, self, "isLoaded") +} + +Bundle_preflightAndReturnError :: proc(self: ^Bundle) -> (ok: BOOL, error: ^Error) { + ok = msgSend(BOOL, self, "preflightAndReturnError:", &error) + return +} + +Bundle_loadAndReturnError :: proc(self: ^Bundle) -> (ok: BOOL, error: ^Error) { + ok = msgSend(BOOL, self, "loadAndReturnError:", &error) + return +} + +Bundle_bundleURL :: proc(self: ^Bundle) -> ^URL { + return msgSend(^URL, self, "bundleURL") +} + +Bundle_resourceURL :: proc(self: ^Bundle) -> ^URL { + return msgSend(^URL, self, "resourceURL") +} + +Bundle_executableURL :: proc(self: ^Bundle) -> ^URL { + return msgSend(^URL, self, "executableURL") +} + +Bundle_URLForAuxiliaryExecutable :: proc(self: ^Bundle, executableName: ^String) -> ^URL { + return msgSend(^URL, self, "URLForAuxiliaryExecutable:", executableName) +} + +Bundle_privateFrameworksURL :: proc(self: ^Bundle) -> ^URL { + return msgSend(^URL, self, "privateFrameworksURL") +} + +Bundle_sharedFrameworksURL :: proc(self: ^Bundle) -> ^URL { + return msgSend(^URL, self, "sharedFrameworksURL") +} + + +Bundle_sharedSupportURL :: proc(self: ^Bundle) -> ^URL { + return msgSend(^URL, self, "sharedSupportURL") +} + +Bundle_builtInPlugInsURL :: proc(self: ^Bundle) -> ^URL { + return msgSend(^URL, self, "builtInPlugInsURL") +} + +Bundle_appStoreReceiptURL :: proc(self: ^Bundle) -> ^URL { + return msgSend(^URL, self, "appStoreReceiptURL") +} + + + + +Bundle_bundlePath :: proc(self: ^Bundle) -> ^String { + return msgSend(^String, self, "bundlePath") +} + +Bundle_resourcePath :: proc(self: ^Bundle) -> ^String { + return msgSend(^String, self, "resourcePath") +} + +Bundle_executablePath :: proc(self: ^Bundle) -> ^String { + return msgSend(^String, self, "executablePath") +} + +Bundle_PathForAuxiliaryExecutable :: proc(self: ^Bundle, executableName: ^String) -> ^String { + return msgSend(^String, self, "PathForAuxiliaryExecutable:", executableName) +} + +Bundle_privateFrameworksPath :: proc(self: ^Bundle) -> ^String { + return msgSend(^String, self, "privateFrameworksPath") +} + +Bundle_sharedFrameworksPath :: proc(self: ^Bundle) -> ^String { + return msgSend(^String, self, "sharedFrameworksPath") +} + + +Bundle_sharedSupportPath :: proc(self: ^Bundle) -> ^String { + return msgSend(^String, self, "sharedSupportPath") +} + +Bundle_builtInPlugInsPath :: proc(self: ^Bundle) -> ^String { + return msgSend(^String, self, "builtInPlugInsPath") +} + +Bundle_appStoreReceiptPath :: proc(self: ^Bundle) -> ^String { + return msgSend(^String, self, "appStoreReceiptPath") +} + +Bundle_bundleIdentifier :: proc(self: ^Bundle) -> ^String { + return msgSend(^String, self, "bundleIdentifier") +} + + +Bundle_infoDictionary :: proc(self: ^Bundle) -> ^Dictionary { + return msgSend(^Dictionary, self, "infoDictionary") +} + +Bundle_localizedInfoDictionary :: proc(self: ^Bundle) -> ^Dictionary { + return msgSend(^Dictionary, self, "localizedInfoDictionary") +} + +Bundle_objectForInfoDictionaryKey :: proc(self: ^Bundle, key: ^String) -> ^Object { + return msgSend(^Object, self, "objectForInfoDictionaryKey:", key) +} + +Bundle_localizedStringForKey :: proc(self: ^Bundle, key: ^String, value: ^String = nil, tableName: ^String = nil) -> ^String { + return msgSend(^String, self, "localizedStringForKey:value:table:", key, value, tableName) +} diff --git a/core/sys/darwin/Foundation/NSDictionary.odin b/core/sys/darwin/Foundation/NSDictionary.odin index 19ea8a491..f82b8cffd 100644 --- a/core/sys/darwin/Foundation/NSDictionary.odin +++ b/core/sys/darwin/Foundation/NSDictionary.odin @@ -24,4 +24,10 @@ Dictionary_objectForKey :: proc(self: ^Dictionary, key: ^Object) -> ^Object { return msgSend(^Dictionary, self, "objectForKey:", key) } -// TODO(bill): enumerator \ No newline at end of file +Dictionary_count :: proc(self: ^Dictionary) -> UInteger { + return msgSend(UInteger, self, "count") +} + +Dictionary_keyEnumerator :: proc(self: ^Dictionary, $KeyType: typeid) -> (enumerator: ^Enumerator(KeyType)) { + return msgSend(type_of(enumerator), self, "keyEnumerator") +} diff --git a/core/sys/darwin/Foundation/NSEnumerator.odin b/core/sys/darwin/Foundation/NSEnumerator.odin new file mode 100644 index 000000000..b6adf2b98 --- /dev/null +++ b/core/sys/darwin/Foundation/NSEnumerator.odin @@ -0,0 +1,37 @@ +package objc_Foundation + +import "core:c" +import "core:intrinsics" + +FastEnumerationState :: struct #packed { + state: c.ulong, + itemsPtr: [^]^Object, + mutationsPtr: [^]c.ulong, + extra: [5]c.ulong, +} + +@(objc_class="NSFastEnumeration") +FastEnumeration :: struct {using _: Object} + +@(objc_class="NSEnumerator") +Enumerator :: struct($T: typeid) where intrinsics.type_is_pointer(T), intrinsics.type_is_subtype_of(T, ^Object) { + using _: FastEnumeration, +} + +FastEnumeration_countByEnumerating :: proc(self: ^FastEnumeration, state: ^FastEnumerationState, buffer: [^]^Object, len: UInteger) -> UInteger { + return msgSend(UInteger, self, "countByEnumeratingWithState:objects:count:", state, buffer, len) +} + +Enumerator_nextObject :: proc(self: ^$E/Enumerator($T)) -> T { + return msgSend(T, self, "nextObject") +} + +Enumerator_allObjects :: proc(self: ^$E/Enumerator($T)) -> (all: Array(T)) { + return msgSend(type_of(all), self, "allObjects") +} + +Enumerator_iterator :: proc(self: ^$E/Enumerator($T)) -> (obj: T, ok: bool) { + obj = msgSend(T, self, "nextObject") + ok = obj != nil + return +} diff --git a/core/sys/darwin/Foundation/NSError.odin b/core/sys/darwin/Foundation/NSError.odin new file mode 100644 index 000000000..85ff5514a --- /dev/null +++ b/core/sys/darwin/Foundation/NSError.odin @@ -0,0 +1,68 @@ +package objc_Foundation + +foreign import "system:Foundation.framework" + +ErrorDomain :: ^String + +foreign Foundation { + CocoaErrorDomain: ErrorDomain + POSIXErrorDomain: ErrorDomain + OSStatusErrorDomain: ErrorDomain + MachErrorDomain: ErrorDomain +} + +ErrorUserInfoKey :: ^String + +foreign Foundation { + UnderlyingErrorKey: ErrorUserInfoKey + LocalizedDescriptionKey: ErrorUserInfoKey + LocalizedFailureReasonErrorKey: ErrorUserInfoKey + LocalizedRecoverySuggestionErrorKey: ErrorUserInfoKey + LocalizedRecoveryOptionsErrorKey: ErrorUserInfoKey + RecoveryAttempterErrorKey: ErrorUserInfoKey + HelpAnchorErrorKey: ErrorUserInfoKey + DebugDescriptionErrorKey: ErrorUserInfoKey + LocalizedFailureErrorKey: ErrorUserInfoKey + StringEncodingErrorKey: ErrorUserInfoKey + URLErrorKey: ErrorUserInfoKey + FilePathErrorKey: ErrorUserInfoKey +} + +@(objc_class="NSError") +Error :: struct { using _: Copying(Error) } + +Error_errorWithDomain :: proc(domain: ErrorDomain, code: Integer, userInfo: ^Dictionary) -> ^Error { + return msgSend(^Error, Error, "errorWithDomain:code:userInfo:", domain, code, userInfo) +} + +Error_initWithDomain :: proc(self: ^Error, domain: ErrorDomain, code: Integer, userInfo: ^Dictionary) -> ^Error { + return msgSend(^Error, self, "initWithDomain:code:userInfo:", domain, code, userInfo) +} + +Error_code :: proc(self: ^Error) -> Integer { + return msgSend(Integer, self, "code") +} + +Error_domain :: proc(self: ^Error) -> ErrorDomain { + return msgSend(ErrorDomain, self, "domain") +} + +Error_userInfo :: proc(self: ^Error) -> ^Dictionary { + return msgSend(^Dictionary, self, "userInfo") +} + +Error_localizedDescription :: proc(self: ^Error) -> ^String { + return msgSend(^String, self, "localizedDescription") +} + +Error_localizedRecoveryOptions :: proc(self: ^Error) -> (options: ^Array(^Object)) { + return msgSend(type_of(options), self, "localizedRecoveryOptions") +} + +Error_localizedRecoverySuggestion :: proc(self: ^Error) -> ^String { + return msgSend(^String, self, "localizedRecoverySuggestion") +} + +Error_localizedFailureReason :: proc(self: ^Error) -> ^String { + return msgSend(^String, self, "localizedFailureReason") +} \ No newline at end of file From ef98e92e8de11a65583ca7bca008e70a33249b01 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Wed, 9 Feb 2022 12:23:41 +0000 Subject: [PATCH 08/64] Remove unneeded file --- core/sys/darwin/Foundation/Foundation.odin | 1 - 1 file changed, 1 deletion(-) delete mode 100644 core/sys/darwin/Foundation/Foundation.odin diff --git a/core/sys/darwin/Foundation/Foundation.odin b/core/sys/darwin/Foundation/Foundation.odin deleted file mode 100644 index c69b10ddb..000000000 --- a/core/sys/darwin/Foundation/Foundation.odin +++ /dev/null @@ -1 +0,0 @@ -package objc_Foundation From b6abaf739ccaa226f2ddf808639994d2c0577258 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Wed, 9 Feb 2022 12:29:52 +0000 Subject: [PATCH 09/64] Add missing calls for `Object`; Add `scoped_autoreleasepool` --- core/sys/darwin/Foundation/NSAutoreleasePool.odin | 5 +++++ core/sys/darwin/Foundation/NSObject.odin | 9 +++++++++ 2 files changed, 14 insertions(+) diff --git a/core/sys/darwin/Foundation/NSAutoreleasePool.odin b/core/sys/darwin/Foundation/NSAutoreleasePool.odin index 5ff2a6f1d..47cbc0e9a 100644 --- a/core/sys/darwin/Foundation/NSAutoreleasePool.odin +++ b/core/sys/darwin/Foundation/NSAutoreleasePool.odin @@ -13,3 +13,8 @@ AutoreleasePool_showPools :: proc(self: ^AutoreleasePool, obj: ^Object) { msgSend(nil, self, "showPools") } + +@(deferred_out=AutoreleasePool_drain) +scoped_autoreleasepool :: proc() -> ^AutoreleasePool { + return init(alloc(AutoreleasePool)) +} \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSObject.odin b/core/sys/darwin/Foundation/NSObject.odin index cf15dd68d..5e2f85ceb 100644 --- a/core/sys/darwin/Foundation/NSObject.odin +++ b/core/sys/darwin/Foundation/NSObject.odin @@ -33,14 +33,19 @@ retain :: proc(self: ^$T) -> ^T where intrinsics.type_is_subtype_of(T, Object) { release :: proc(self: ^$T) where intrinsics.type_is_subtype_of(T, Object) { msgSend(nil, self, "release") } +autorelease :: proc(self: ^$T) where intrinsics.type_is_subtype_of(T, Object) { + msgSend(nil, self, "autorelease") +} retainCount :: proc(self: ^$T) -> UInteger where intrinsics.type_is_subtype_of(T, Object) { return msgSend(UInteger, self, "retainCount") } + copy :: proc(self: ^Copying($T)) -> ^T where intrinsics.type_is_subtype_of(T, Object) { return msgSend(^T, self, "copy") } + hash :: proc(self: ^Object) -> UInteger { return msgSend(UInteger, self, "hash") } @@ -60,6 +65,10 @@ debugDescription :: proc(self: ^Object) -> ^String { return nil } +bridgingCast :: proc($T: typeid, obj: ^Object) where intrinsics.type_is_pointer(T), intrinsics.type_is_subtype_of(T, ^Object) { + return (T)(obj) +} + @(objc_class="NSCoder") Coder :: struct {using _: Object} From 42a1c58a8090bb3f5f6ac46db5f82edc3df49213 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Wed, 9 Feb 2022 21:42:20 +0000 Subject: [PATCH 10/64] Update Foundation linking --- core/sys/darwin/Foundation/NSError.odin | 32 ++++++++++++------------ core/sys/darwin/Foundation/NSNumber.odin | 30 +++++++++++----------- core/sys/darwin/Foundation/NSObject.odin | 2 +- 3 files changed, 32 insertions(+), 32 deletions(-) diff --git a/core/sys/darwin/Foundation/NSError.odin b/core/sys/darwin/Foundation/NSError.odin index 85ff5514a..aebf01035 100644 --- a/core/sys/darwin/Foundation/NSError.odin +++ b/core/sys/darwin/Foundation/NSError.odin @@ -5,27 +5,27 @@ foreign import "system:Foundation.framework" ErrorDomain :: ^String foreign Foundation { - CocoaErrorDomain: ErrorDomain - POSIXErrorDomain: ErrorDomain - OSStatusErrorDomain: ErrorDomain - MachErrorDomain: ErrorDomain + @(linkage="weak") CocoaErrorDomain: ErrorDomain + @(linkage="weak") POSIXErrorDomain: ErrorDomain + @(linkage="weak") OSStatusErrorDomain: ErrorDomain + @(linkage="weak") MachErrorDomain: ErrorDomain } ErrorUserInfoKey :: ^String foreign Foundation { - UnderlyingErrorKey: ErrorUserInfoKey - LocalizedDescriptionKey: ErrorUserInfoKey - LocalizedFailureReasonErrorKey: ErrorUserInfoKey - LocalizedRecoverySuggestionErrorKey: ErrorUserInfoKey - LocalizedRecoveryOptionsErrorKey: ErrorUserInfoKey - RecoveryAttempterErrorKey: ErrorUserInfoKey - HelpAnchorErrorKey: ErrorUserInfoKey - DebugDescriptionErrorKey: ErrorUserInfoKey - LocalizedFailureErrorKey: ErrorUserInfoKey - StringEncodingErrorKey: ErrorUserInfoKey - URLErrorKey: ErrorUserInfoKey - FilePathErrorKey: ErrorUserInfoKey + @(linkage="weak") UnderlyingErrorKey: ErrorUserInfoKey + @(linkage="weak") LocalizedDescriptionKey: ErrorUserInfoKey + @(linkage="weak") LocalizedFailureReasonErrorKey: ErrorUserInfoKey + @(linkage="weak") LocalizedRecoverySuggestionErrorKey: ErrorUserInfoKey + @(linkage="weak") LocalizedRecoveryOptionsErrorKey: ErrorUserInfoKey + @(linkage="weak") RecoveryAttempterErrorKey: ErrorUserInfoKey + @(linkage="weak") HelpAnchorErrorKey: ErrorUserInfoKey + @(linkage="weak") DebugDescriptionErrorKey: ErrorUserInfoKey + @(linkage="weak") LocalizedFailureErrorKey: ErrorUserInfoKey + @(linkage="weak") StringEncodingErrorKey: ErrorUserInfoKey + @(linkage="weak") URLErrorKey: ErrorUserInfoKey + @(linkage="weak") FilePathErrorKey: ErrorUserInfoKey } @(objc_class="NSError") diff --git a/core/sys/darwin/Foundation/NSNumber.odin b/core/sys/darwin/Foundation/NSNumber.odin index 3b8e59419..2630e6daa 100644 --- a/core/sys/darwin/Foundation/NSNumber.odin +++ b/core/sys/darwin/Foundation/NSNumber.odin @@ -16,8 +16,8 @@ Value_valueWithPointer :: proc(pointer: rawptr) -> ^Value { return msgSend(^Value, Value, "valueWithPointer:", pointer) } -Value_initWithBytes :: proc(value: rawptr, type: cstring) -> ^Value { - return msgSend(^Value, Value, "initWithBytes:objCType:", value, type) +Value_initWithBytes :: proc(self: ^Value, value: rawptr, type: cstring) -> ^Value { + return msgSend(^Value, self, "initWithBytes:objCType:", value, type) } Value_initWithCoder :: proc(coder: ^Coder) -> ^Value { @@ -46,19 +46,19 @@ Value_pointerValue :: proc(self: ^Value) -> rawptr { Number :: struct{using _: Copying(Number), using _: Value} -Number_numberWithI8 :: proc(value: i8) -> ^Number { return msgSend(^Number, Number, "numberWithChar:", value) } -Number_numberWithU8 :: proc(value: u8) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedChar:", value) } -Number_numberWithI16 :: proc(value: i16) -> ^Number { return msgSend(^Number, Number, "numberWithShort:", value) } -Number_numberWithU16 :: proc(value: u16) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedShort:", value) } -Number_numberWithI32 :: proc(value: i32) -> ^Number { return msgSend(^Number, Number, "numberWithInt:", value) } -Number_numberWithU32 :: proc(value: u32) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedInt:", value) } -Number_numberWithInt :: proc(value: int) -> ^Number { return msgSend(^Number, Number, "numberWithLong:", value) } -Number_numberWithUint :: proc(value: uint) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLong:", value) } -Number_numberWithU64 :: proc(value: u64) -> ^Number { return msgSend(^Number, Number, "numberWithLongLong:", value) } -Number_numberWithI64 :: proc(value: i64) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLongLong:", value) } -Number_numberWithF32 :: proc(value: f32) -> ^Number { return msgSend(^Number, Number, "numberWithFloat:", value) } -Number_numberWithF64 :: proc(value: f64) -> ^Number { return msgSend(^Number, Number, "numberWithDouble:", value) } -Number_numberWithBool :: proc(value: BOOL) -> ^Number { return msgSend(^Number, Number, "numberWithBool:", value) } +Number_numberWithI8 :: proc(value: i8) -> ^Number { return msgSend(^Number, Number, "numberWithChar:", value) } +Number_numberWithU8 :: proc(value: u8) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedChar:", value) } +Number_numberWithI16 :: proc(value: i16) -> ^Number { return msgSend(^Number, Number, "numberWithShort:", value) } +Number_numberWithU16 :: proc(value: u16) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedShort:", value) } +Number_numberWithI32 :: proc(value: i32) -> ^Number { return msgSend(^Number, Number, "numberWithInt:", value) } +Number_numberWithU32 :: proc(value: u32) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedInt:", value) } +Number_numberWithInt :: proc(value: int) -> ^Number { return msgSend(^Number, Number, "numberWithLong:", value) } +Number_numberWithUint :: proc(value: uint) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLong:", value) } +Number_numberWithU64 :: proc(value: u64) -> ^Number { return msgSend(^Number, Number, "numberWithLongLong:", value) } +Number_numberWithI64 :: proc(value: i64) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLongLong:", value) } +Number_numberWithF32 :: proc(value: f32) -> ^Number { return msgSend(^Number, Number, "numberWithFloat:", value) } +Number_numberWithF64 :: proc(value: f64) -> ^Number { return msgSend(^Number, Number, "numberWithDouble:", value) } +Number_numberWithBool :: proc(value: BOOL) -> ^Number { return msgSend(^Number, Number, "numberWithBool:", value) } Number_number :: proc{ Number_numberWithI8, diff --git a/core/sys/darwin/Foundation/NSObject.odin b/core/sys/darwin/Foundation/NSObject.odin index 5e2f85ceb..d61f8e947 100644 --- a/core/sys/darwin/Foundation/NSObject.odin +++ b/core/sys/darwin/Foundation/NSObject.odin @@ -24,7 +24,7 @@ Copying :: struct($T: typeid) {using _: Object} alloc :: proc($T: typeid) -> ^T where intrinsics.type_is_subtype_of(T, Object) { return msgSend(^T, T, "alloc") } -init :: proc(self: ^$T) -> ^T where intrinsics.type_is_subtype_of(T, Object){ +init :: proc(self: ^$T) -> ^T where intrinsics.type_is_subtype_of(T, Object) { return msgSend(^T, self, "init") } retain :: proc(self: ^$T) -> ^T where intrinsics.type_is_subtype_of(T, Object) { From c3809d7b84fedb633eaf599bcb9a8cb0534ba2ee Mon Sep 17 00:00:00 2001 From: gingerBill Date: Wed, 9 Feb 2022 21:46:26 +0000 Subject: [PATCH 11/64] Fix typo --- core/sys/darwin/Foundation/NSString.odin | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/core/sys/darwin/Foundation/NSString.odin b/core/sys/darwin/Foundation/NSString.odin index 857e27f12..86c8cabea 100644 --- a/core/sys/darwin/Foundation/NSString.odin +++ b/core/sys/darwin/Foundation/NSString.odin @@ -87,12 +87,12 @@ String_cStringUsingEncoding :: proc(self: ^String, encoding: StringEncoding) -> return msgSend(cstring, self, "cStringUsingEncoding:", encoding) } -String_UTFString :: proc(self: ^String) -> cstring { - return msgSend(cstring, self, "UTFString") +String_UTF8String :: proc(self: ^String) -> cstring { + return msgSend(cstring, self, "UTF8String") } String_OdinString :: proc(self: ^String) -> string { - return string(String_UTFString(self)) + return string(String_UTF8String(self)) } String_maximumLengthOfBytesUsingEncoding :: proc(self: ^String, encoding: StringEncoding) -> UInteger { From 416413bebfcddf2b7ae2bf20fb01b675339297eb Mon Sep 17 00:00:00 2001 From: gingerBill Date: Thu, 10 Feb 2022 14:35:10 +0000 Subject: [PATCH 12/64] Begin work on `Metal` --- vendor/Metal/MTLAccelerationStructure.odin | 270 ++++++++++++++++++ .../Metal/MTLAccelerationStructureTypes.odin | 10 + vendor/Metal/MTLRenderPipeline.odin | 74 +++++ .../Metal/MTLStageInputOutputDescriptor.odin | 76 +++++ vendor/Metal/Metal.odin | 22 ++ vendor/Metal/NSBuffer.odin | 5 + vendor/Metal/NSResource.odin | 5 + 7 files changed, 462 insertions(+) create mode 100644 vendor/Metal/MTLAccelerationStructure.odin create mode 100644 vendor/Metal/MTLAccelerationStructureTypes.odin create mode 100644 vendor/Metal/MTLRenderPipeline.odin create mode 100644 vendor/Metal/MTLStageInputOutputDescriptor.odin create mode 100644 vendor/Metal/Metal.odin create mode 100644 vendor/Metal/NSBuffer.odin create mode 100644 vendor/Metal/NSResource.odin diff --git a/vendor/Metal/MTLAccelerationStructure.odin b/vendor/Metal/MTLAccelerationStructure.odin new file mode 100644 index 000000000..342df3d07 --- /dev/null +++ b/vendor/Metal/MTLAccelerationStructure.odin @@ -0,0 +1,270 @@ +package objc_Metal + +import NS "core:sys/darwin/Foundation" + +AccelerationStructureUsage :: distinct bit_set[AccelerationStructureUsageFlag; NS.UInteger] +AccelerationStructureUsageFlag :: enum NS.UInteger { + Refit = 0, + PreferFastBuild = 1, + ExtendedLimits = 2, +} +AccelerationStructureUsageNone :: AccelerationStructureUsage{} + +AccelerationStructureInstanceOptions :: distinct bit_set[AccelerationStructureInstanceOption; u32] +AccelerationStructureInstanceOption :: enum u32 { + DisableTriangleCulling = 0, + TriangleFrontFacingWindingCounterClockwise = 1, + Opaque = 2, + NonOpaque = 3, +} +AccelerationStructureInstanceOptionNone :: AccelerationStructureInstanceOptions{} + +MotionBorderMode :: enum u32 { + Clamp = 0, + Vanish = 1, +} + +AccelerationStructureInstanceDescriptor :: struct #packed { + transformationMatrix: PackedFloat4x3, + options: AccelerationStructureInstanceOptions, + mask: u32, + intersectionFunctionTableOffset: u32, + accelerationStructureIndex: u32, +} + +AccelerationStructureUserIDInstanceDescriptor :: struct #packed { + transformationMatrix: PackedFloat4x3, + options: AccelerationStructureInstanceOptions, + mask: u32, + intersectionFunctionTableOffset: u32, + accelerationStructureIndex: u32, + userID: u32, +} + +AccelerationStructureInstanceDescriptorType :: enum NS.UInteger { + Default = 0, + UserID = 1, + Motion = 2, +} + +AccelerationStructureMotionInstanceDescriptor :: struct #packed { + options: AccelerationStructureInstanceOptions, + mask: u32, + intersectionFunctionTableOffset: u32, + accelerationStructureIndex: u32, + userID: u32, + motionTransformsStartIndex: u32, + motionTransformsCount: u32, + motionStartBorderMode: MotionBorderMode, + motionEndBorderMode: MotionBorderMode, + motionStartTime: f32, + motionEndTime: f32, +} + +@(objc_class="NSAccelerationStructureDescriptor") +AccelerationStructureDescriptor :: struct { using _: NS.Copying(AccelerationStructureDescriptor) } + +@(objc_class="NSAccelerationStructureGeometryDescriptor") +AccelerationStructureGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureGeometryDescriptor) } + +@(objc_class="NSPrimitiveAccelerationStructureDescriptor") +PrimitiveAccelerationStructureDescriptor :: struct { using _: NS.Copying(PrimitiveAccelerationStructureDescriptor), using _: AccelerationStructureDescriptor } + +@(objc_class="NSAccelerationStructureTriangleGeometryDescriptor") +AccelerationStructureTriangleGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureTriangleGeometryDescriptor), using _: AccelerationStructureGeometryDescriptor } + +@(objc_class="NSAccelerationStructureBoundingBoxGeometryDescriptor") +AccelerationStructureBoundingBoxGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureBoundingBoxGeometryDescriptor), using _: AccelerationStructureGeometryDescriptor } + +@(objc_class="NSMotionKeyframeData") +MotionKeyframeData :: struct { using _: NS.Object } + +@(objc_class="NSAccelerationStructureMotionTriangleGeometryDescriptor") +AccelerationStructureMotionTriangleGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureMotionTriangleGeometryDescriptor), using _: AccelerationStructureGeometryDescriptor } + +@(objc_class="NSAccelerationStructureMotionBoundingBoxGeometryDescriptor") +AccelerationStructureMotionBoundingBoxGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureMotionBoundingBoxGeometryDescriptor), using _: AccelerationStructureGeometryDescriptor } + +@(objc_class="NSInstanceAccelerationStructureDescriptor") +InstanceAccelerationStructureDescriptor :: struct { using _: NS.Copying(InstanceAccelerationStructureDescriptor), using _: AccelerationStructureGeometryDescriptor } + +@(objc_class="NSAccelerationStructure") +AccelerationStructure :: struct { using _: NS.Object } + + + +AccelerationStructureDescriptor_usage :: proc(self: ^AccelerationStructureDescriptor) -> AccelerationStructureUsage { + return msgSend(AccelerationStructureUsage, self, "usage") +} + +AccelerationStructureGeometryDescriptor_intersectionFunctionTableOffset :: proc(self: ^AccelerationStructureGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "intersectionFunctionTableOffset") +} + +AccelerationStructureGeometryDescriptor_setIntersectionFunctionTableOffset :: proc(self: ^AccelerationStructureGeometryDescriptor, intersectionFunctionTableOffset: NS.UInteger) { + msgSend(nil, self, "setIntersectionFunctionTableOffset:", intersectionFunctionTableOffset) +} + +AccelerationStructureGeometryDescriptor_opaque :: proc(self: ^AccelerationStructureGeometryDescriptor) -> BOOL { + return msgSend(BOOL, self, "opaque") +} + +AccelerationStructureGeometryDescriptor_setOpaque :: proc(self: ^AccelerationStructureGeometryDescriptor, opaque: BOOL) { + msgSend(nil, self, "setOpaque:", opaque) +} + +AccelerationStructureGeometryDescriptor_allowDuplicateIntersectionFunctionInvocation :: proc(self: ^AccelerationStructureGeometryDescriptor) -> BOOL { + return msgSend(BOOL, self, "allowDuplicateIntersectionFunctionInvocation") +} + +AccelerationStructureGeometryDescriptor_setAllowDuplicateIntersectionFunctionInvocation :: proc(self: ^AccelerationStructureGeometryDescriptor, allowDuplicateIntersectionFunctionInvocation: BOOL) { + msgSend(nil, self, "setAllowDuplicateIntersectionFunctionInvocation:", allowDuplicateIntersectionFunctionInvocation) +} + + +AccelerationStructureGeometryDescriptor_label :: proc(self: ^AccelerationStructureGeometryDescriptor) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} + +AccelerationStructureGeometryDescriptor_setLabel :: proc(self: ^AccelerationStructureGeometryDescriptor, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} + +PrimitiveAccelerationStructureDescriptor_geometryDescriptors :: proc(self: ^PrimitiveAccelerationStructureDescriptor) -> (descriptors: ^NS.Array(^NS.Object)) { + return msgSend(type_of(descriptors), self, "geometryDescriptors") +} + +PrimitiveAccelerationStructureDescriptor_setGeometryDescriptors :: proc(self: ^PrimitiveAccelerationStructureDescriptor, descriptors: ^NS.Array(^NS.Object)) { + msgSend(nil, self, "setGeometryDescriptors:", descriptors) +} + +PrimitiveAccelerationStructureDescriptor_motionStartBorderMode :: proc(self: ^PrimitiveAccelerationStructureDescriptor) -> MotionBorderMode { + return msgSend(MotionBorderMode, self, "motionStartBorderMode") +} +PrimitiveAccelerationStructureDescriptor_setMotionStartBorderMode :: proc(self: ^PrimitiveAccelerationStructureDescriptor, motionStartBorderMode: MotionBorderMode) { + msgSend(nil, self, "setMotionStartBorderMode:", motionStartBorderMode) +} + +PrimitiveAccelerationStructureDescriptor_motionEndBorderMode :: proc(self: ^PrimitiveAccelerationStructureDescriptor) -> MotionBorderMode { + return msgSend(MotionBorderMode, self, "motionEndBorderMode") +} +PrimitiveAccelerationStructureDescriptor_setMotionEndBorderMode :: proc(self: ^PrimitiveAccelerationStructureDescriptor, motionEndBorderMode: MotionBorderMode) { + msgSend(nil, self, "setMotionEndBorderMode:", motionEndBorderMode) +} + +PrimitiveAccelerationStructureDescriptor_motionStartTime :: proc(self: ^PrimitiveAccelerationStructureDescriptor) -> (motionStartTime: f32) { + return msgSend(f32, self, "motionStartTime") +} +PrimitiveAccelerationStructureDescriptor_setMotionStartTime :: proc(self: ^PrimitiveAccelerationStructureDescriptor, motionStartTime: f32) { + msgSend(nil, self, "setMotionStartTime:", motionStartTime) +} + + +PrimitiveAccelerationStructureDescriptor_motionEndTime :: proc(self: ^PrimitiveAccelerationStructureDescriptor) -> (motionEndTime: f32) { + return msgSend(f32, self, "motionEndTime") +} +PrimitiveAccelerationStructureDescriptor_setMotionEndTime :: proc(self: ^PrimitiveAccelerationStructureDescriptor, motionEndTime: f32) { + msgSend(nil, self, "setMotionEndTime:", motionEndTime) +} + + +PrimitiveAccelerationStructureDescriptor_motionKeyframeCount :: proc(self: ^PrimitiveAccelerationStructureDescriptor) -> (motionKeyframeCount: NS.UInteger) { + return msgSend(NS.UInteger, self, "motionKeyframeCount") +} +PrimitiveAccelerationStructureDescriptor_setmotionKeyframeCount :: proc(self: ^PrimitiveAccelerationStructureDescriptor, motionKeyframeCount: NS.UInteger) { + msgSend(nil, self, "setMotionKeyframeCount:", motionKeyframeCount) +} + +PrimitiveAccelerationStructureDescriptor_descriptor :: proc() -> ^PrimitiveAccelerationStructureDescriptor { + return msgSend(^PrimitiveAccelerationStructureDescriptor, PrimitiveAccelerationStructureDescriptor, "descriptor") +} + + +AccelerationStructureTriangleGeometryDescriptor_vertexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^Buffer { + return msgSend(^Buffer, self, "vertexBuffer") +} +AccelerationStructureTriangleGeometryDescriptor_setVertexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, buffer: ^Buffer) { + msgSend(nil, self, "setVertexBuffer:", buffer) +} + +AccelerationStructureTriangleGeometryDescriptor_vertexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "vertexBufferOffset") +} +AccelerationStructureTriangleGeometryDescriptor_setVertexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexBufferOffset: NS.UInteger) { + msgSend(nil, self, "setVertexBufferOffset:", vertexBufferOffset) +} + +AccelerationStructureTriangleGeometryDescriptor_vertexStride :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "vertexStride") +} +AccelerationStructureTriangleGeometryDescriptor_setVertexStride :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexStride: NS.UInteger) { + msgSend(nil, self, "setVertexStride:", vertexStride) +} + +AccelerationStructureTriangleGeometryDescriptor_indexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^Buffer { + return msgSend(^Buffer, self, "indexBuffer") +} +AccelerationStructureTriangleGeometryDescriptor_setIndexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, buffer: ^Buffer) { + msgSend(nil, self, "setIndexBuffer:", buffer) +} + +AccelerationStructureTriangleGeometryDescriptor_indexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "indexBufferOffset") +} +AccelerationStructureTriangleGeometryDescriptor_setIndexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexBufferOffset: NS.UInteger) { + msgSend(nil, self, "setIndexBufferOffset:", indexBufferOffset) +} + + + +AccelerationStructureTriangleGeometryDescriptor_indexType :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> IndexType { + return msgSend(IndexType, self, "indexType") +} +AccelerationStructureTriangleGeometryDescriptor_setIndexType :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indextype: IndexType) { + msgSend(nil, self, "setIndexType:", indextype) +} + +AccelerationStructureTriangleGeometryDescriptor_triangleCount :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "triangleCount") +} +AccelerationStructureTriangleGeometryDescriptor_setTriangleCount :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, triangleCount: NS.UInteger) { + msgSend(nil, self, "setTriangleCount", triangleCount) +} + + +AccelerationStructureTriangleGeometryDescriptor_descriptor :: proc() -> ^AccelerationStructureTriangleGeometryDescriptor { + return msgSend(^AccelerationStructureTriangleGeometryDescriptor, AccelerationStructureTriangleGeometryDescriptor, "descriptor") +} + +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBuffer :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> ^Buffer { + return msgSend(^Buffer, self, "boundingBoxBuffer") +} + +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBuffer :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, buffer: ^Buffer) { + msgSend(nil, self, "setBoundingBoxBuffer:", buffer) +} + +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBufferOffset :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "boundingBoxBufferOffset") +} + +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBufferOffset :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBufferOffset: NS.UInteger) { + msgSend(nil, self, "setBoundingBoxBufferOffset:", boundingBoxBufferOffset) +} + + +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxStride :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "boundingBoxStride") +} + +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxStride :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxStride: NS.UInteger) { + msgSend(nil, self, "setBoundingBoxStride:", boundingBoxStride) +} + +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxCount :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "boundingBoxCount") +} + +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxCount :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxCount: NS.UInteger) { + msgSend(nil, self, "setBoundingBoxCount:", boundingBoxCount) +} diff --git a/vendor/Metal/MTLAccelerationStructureTypes.odin b/vendor/Metal/MTLAccelerationStructureTypes.odin new file mode 100644 index 000000000..eba672836 --- /dev/null +++ b/vendor/Metal/MTLAccelerationStructureTypes.odin @@ -0,0 +1,10 @@ +package objc_Metal + +import NS "core:sys/darwin/Foundation" + +PackedFloat3 :: distinct [3]f32 +PackedFloat4x3 :: distinct [4]PackedFloat3 + +AxisAlignedBoundingBox :: struct{ + min, ax: PackedFloat3, +} \ No newline at end of file diff --git a/vendor/Metal/MTLRenderPipeline.odin b/vendor/Metal/MTLRenderPipeline.odin new file mode 100644 index 000000000..c05c02c64 --- /dev/null +++ b/vendor/Metal/MTLRenderPipeline.odin @@ -0,0 +1,74 @@ +package objc_Metal + +import NS "core:sys/darwin/Foundation" + +BlendFactor :: enum NS.UInteger { + Zero = 0, + One = 1, + SourceColor = 2, + OneMinusSourceColor = 3, + SourceAlpha = 4, + OneMinusSourceAlpha = 5, + DestinationColor = 6, + OneMinusDestinationColor = 7, + DestinationAlpha = 8, + OneMinusDestinationAlpha = 9, + SourceAlphaSaturated = 10, + BlendColor = 11, + OneMinusBlendColor = 12, + BlendAlpha = 13, + OneMinusBlendAlpha = 14, + Source1Color = 15, + OneMinusSource1Color = 16, + Source1Alpha = 17, + OneMinusSource1Alpha = 18, +} + +BlendOperation :: enum NS.UInteger { + Add = 0, + Subtract = 1, + ReverseSubtract = 2, + Min = 3, + Max = 4, +} + +ColorWriteMaskOption :: enum NS.UInteger { + Alpha = 0, + Blue = 1, + Green = 2, + Red = 3, +} +ColorWriteMask :: distinct bit_set[ColorWriteMaskOption; NS.UInteger] +ColorWriteMaskNone :: ColorWriteMask{} +ColorWriteMaskAll :: ColorWriteMask{.Alpha, .Blue, .Green, .Red} + +PrimitiveTopologyClass :: enum NS.UInteger { + ClassUnspecified = 0, + ClassPoint = 1, + ClassLine = 2, + ClassTriangle = 3, +} + +TessellationPartitionMode :: enum NS.UInteger { + ModePow2 = 0, + ModeInteger = 1, + ModeFractionalOdd = 2, + ModeFractionalEven = 3, +} + +TessellationFactorStepFunction :: enum NS.UInteger { + Constant = 0, + PerPatch = 1, + PerInstance = 2, + PerPatchAndPerInstance = 3, +} + +TessellationFactorFormat :: enum NS.UInteger { + Half = 0, +} + +TessellationControlPointIndexType :: enum NS.UInteger { + None = 0, + UInt16 = 1, + UInt32 = 2, +} diff --git a/vendor/Metal/MTLStageInputOutputDescriptor.odin b/vendor/Metal/MTLStageInputOutputDescriptor.odin new file mode 100644 index 000000000..98ff66ce5 --- /dev/null +++ b/vendor/Metal/MTLStageInputOutputDescriptor.odin @@ -0,0 +1,76 @@ +package objc_Metal + +import NS "core:sys/darwin/Foundation" + + +AttributeFormat :: enum NS.UInteger { + Invalid = 0, + UChar2 = 1, + UChar3 = 2, + UChar4 = 3, + Char2 = 4, + Char3 = 5, + Char4 = 6, + UChar2Normalized = 7, + UChar3Normalized = 8, + UChar4Normalized = 9, + Char2Normalized = 10, + Char3Normalized = 11, + Char4Normalized = 12, + UShort2 = 13, + UShort3 = 14, + UShort4 = 15, + Short2 = 16, + Short3 = 17, + Short4 = 18, + UShort2Normalized = 19, + UShort3Normalized = 20, + UShort4Normalized = 21, + Short2Normalized = 22, + Short3Normalized = 23, + Short4Normalized = 24, + Half2 = 25, + Half3 = 26, + Half4 = 27, + Float = 28, + Float2 = 29, + Float3 = 30, + Float4 = 31, + Int = 32, + Int2 = 33, + Int3 = 34, + Int4 = 35, + UInt = 36, + UInt2 = 37, + UInt3 = 38, + UInt4 = 39, + Int1010102Normalized = 40, + UInt1010102Normalized = 41, + UChar4Normalized_BGRA = 42, + UChar = 45, + Char = 46, + UCharNormalized = 47, + CharNormalized = 48, + UShort = 49, + Short = 50, + UShortNormalized = 51, + ShortNormalized = 52, + Half = 53, +} + +IndexType :: enum NS.UInteger { + UInt16 = 0, + UInt32 = 1, +} + +StepFunction :: enum NS.UInteger { + Constant = 0, + PerVertex = 1, + PerInstance = 2, + PerPatch = 3, + PerPatchControlPoint = 4, + ThreadPositionInGridX = 5, + ThreadPositionInGridY = 6, + ThreadPositionInGridXIndexed = 7, + ThreadPositionInGridYIndexed = 8, +} \ No newline at end of file diff --git a/vendor/Metal/Metal.odin b/vendor/Metal/Metal.odin new file mode 100644 index 000000000..eefada00d --- /dev/null +++ b/vendor/Metal/Metal.odin @@ -0,0 +1,22 @@ +package objc_Metal + +import NS "core:sys/darwin/Foundation" +import "core:intrinsics" + +alloc :: NS.alloc +init :: NS.init +retain :: NS.retain +release :: NS.release +autorelease :: NS.autorelease +retainCount :: NS.retainCount +copy :: NS.copy +hash :: NS.hash +isEqual :: NS.isEqual +description :: NS.description +debugDescription :: NS.debugDescription +bridgingCast :: NS.bridgingCast + +@(private) +msgSend :: intrinsics.objc_send + +BOOL :: NS.BOOL \ No newline at end of file diff --git a/vendor/Metal/NSBuffer.odin b/vendor/Metal/NSBuffer.odin new file mode 100644 index 000000000..9f7a83c1a --- /dev/null +++ b/vendor/Metal/NSBuffer.odin @@ -0,0 +1,5 @@ +package objc_Metal + +import NS "core:sys/darwin/Foundation" + +Buffer :: struct { using _: Resource } \ No newline at end of file diff --git a/vendor/Metal/NSResource.odin b/vendor/Metal/NSResource.odin new file mode 100644 index 000000000..34bc0267c --- /dev/null +++ b/vendor/Metal/NSResource.odin @@ -0,0 +1,5 @@ +package objc_Metal + +import NS "core:sys/darwin/Foundation" + +Resource :: struct { using _: NS.Object } \ No newline at end of file From f8afda3b221f6c2279a393c2c0fb8ab7ea1d59df Mon Sep 17 00:00:00 2001 From: gingerBill Date: Fri, 11 Feb 2022 22:54:51 +0000 Subject: [PATCH 13/64] Add more objc attributes --- core/sys/darwin/Foundation/NSArray.odin | 36 +++-- .../darwin/Foundation/NSAutoreleasePool.odin | 15 +- core/sys/darwin/Foundation/NSBundle.odin | 56 +++++-- core/sys/darwin/Foundation/NSData.odin | 12 ++ core/sys/darwin/Foundation/NSDate.odin | 12 ++ core/sys/darwin/Foundation/NSDictionary.odin | 18 +++ core/sys/darwin/Foundation/NSEnumerator.odin | 15 +- core/sys/darwin/Foundation/NSError.odin | 22 ++- core/sys/darwin/Foundation/NSLock.odin | 24 +++ .../sys/darwin/Foundation/NSNotification.odin | 15 ++ core/sys/darwin/Foundation/NSNumber.odin | 145 ++++++++++-------- core/sys/darwin/Foundation/NSObject.odin | 36 +++-- core/sys/darwin/Foundation/NSString.odin | 24 +++ core/sys/darwin/Foundation/NSURL.odin | 12 ++ src/check_builtin.cpp | 8 +- src/check_decl.cpp | 63 ++++++++ src/check_type.cpp | 2 + src/checker.cpp | 50 +++++- src/checker.hpp | 6 +- src/entity.cpp | 23 +++ src/llvm_backend_expr.cpp | 11 +- src/main.cpp | 32 +--- src/string.cpp | 31 ++++ src/types.cpp | 62 ++++++++ 24 files changed, 588 insertions(+), 142 deletions(-) diff --git a/core/sys/darwin/Foundation/NSArray.odin b/core/sys/darwin/Foundation/NSArray.odin index 435e239a2..e17223ff7 100644 --- a/core/sys/darwin/Foundation/NSArray.odin +++ b/core/sys/darwin/Foundation/NSArray.odin @@ -3,26 +3,40 @@ package objc_Foundation import "core:intrinsics" @(objc_class="NSArray") -Array :: struct($T: typeid) where intrinsics.type_is_pointer(T), intrinsics.type_is_subtype_of(T, ^Object) { - using _: Copying(Array(T)), +Array :: struct { + using _: Copying(Array), } -Array_initWithObjects :: proc(self: ^$A/Array($T), objects: [^]^Object, count: UInteger) -> ^A { - return msgSend(^A, "initWithObjects:count:", objects, count) +@(objc_type=Array, objc_class_name="alloc") +Array_alloc :: proc() -> ^Array { + return msgSend(^Array, Array, "alloc") } -Array_initWithCoder :: proc(self: ^$A/Array($T), coder: ^Coder) -> ^A { - return msgSend(^A, "initWithCoder:", coder) +@(objc_type=Array, objc_name="init") +Array_init :: proc(self: ^Array) -> ^Array { + return msgSend(^Array, self, "init") } -Array_objectAtIndex :: proc(self: ^Array($T), index: UInteger) -> ^Object { +@(objc_type=Array, objc_name="initWithObjects") +Array_initWithObjects :: proc(self: ^Array, objects: [^]^Object, count: UInteger) -> ^Array { + return msgSend(^Array, self, "initWithObjects:count:", objects, count) +} + +@(objc_type=Array, objc_name="initWithCoder") +Array_initWithCoder :: proc(self: ^Array, coder: ^Coder) -> ^Array { + return msgSend(^Array, self, "initWithCoder:", coder) +} + +@(objc_type=Array, objc_name="object") +Array_object :: proc(self: ^Array, index: UInteger) -> ^Object { return msgSend(^Object, self, "objectAtIndex:", index) } - -Array_object :: proc(self: ^Array($T), index: UInteger) -> T { - return (T)(Array_objectAtIndex(self, index)) +@(objc_type=Array, objc_name="objectAs") +Array_objectAs :: proc(self: ^Array, index: UInteger, $T: typeid) -> T where intrinsics.type_is_pointer(T), intrinsics.type_is_subtype_of(T, ^Object) { + return (T)(Array_object(self, index)) } -Array_count :: proc(self: ^Array($T)) -> UInteger { +@(objc_type=Array, objc_name="count") +Array_count :: proc(self: ^Array) -> UInteger { return msgSend(UInteger, self, "count") } diff --git a/core/sys/darwin/Foundation/NSAutoreleasePool.odin b/core/sys/darwin/Foundation/NSAutoreleasePool.odin index 47cbc0e9a..17ec88ba1 100644 --- a/core/sys/darwin/Foundation/NSAutoreleasePool.odin +++ b/core/sys/darwin/Foundation/NSAutoreleasePool.odin @@ -3,12 +3,25 @@ package objc_Foundation @(objc_class="NSAutoreleasePool") AutoreleasePool :: struct {using _: Object} +@(objc_type=AutoreleasePool, objc_class_name="alloc") +AutoreleasePool_alloc :: proc() -> ^AutoreleasePool { + return msgSend(^AutoreleasePool, AutoreleasePool, "alloc") +} + +@(objc_type=AutoreleasePool, objc_name="init") +AutoreleasePool_init :: proc(self: ^AutoreleasePool) -> ^AutoreleasePool { + return msgSend(^AutoreleasePool, self, "init") +} + +@(objc_type=AutoreleasePool, objc_name="drain") AutoreleasePool_drain :: proc(self: ^AutoreleasePool) { msgSend(nil, self, "drain") } +@(objc_type=AutoreleasePool, objc_name="addObject") AutoreleasePool_addObject :: proc(self: ^AutoreleasePool, obj: ^Object) { msgSend(nil, self, "addObject:", obj) } +@(objc_type=AutoreleasePool, objc_name="showPools") AutoreleasePool_showPools :: proc(self: ^AutoreleasePool, obj: ^Object) { msgSend(nil, self, "showPools") } @@ -16,5 +29,5 @@ AutoreleasePool_showPools :: proc(self: ^AutoreleasePool, obj: ^Object) { @(deferred_out=AutoreleasePool_drain) scoped_autoreleasepool :: proc() -> ^AutoreleasePool { - return init(alloc(AutoreleasePool)) + return AutoreleasePool.alloc()->init() } \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSBundle.odin b/core/sys/darwin/Foundation/NSBundle.odin index 375e15b65..a18809b7e 100644 --- a/core/sys/darwin/Foundation/NSBundle.odin +++ b/core/sys/darwin/Foundation/NSBundle.odin @@ -3,98 +3,120 @@ package objc_Foundation @(objc_class="NSBundle") Bundle :: struct { using _: Object } +@(objc_type=Bundle, objc_class_name="mainBundle") Bundle_mainBundle :: proc() -> ^Bundle { return msgSend(^Bundle, Bundle, "mainBundle") } +@(objc_type=Bundle, objc_class_name="bundleWithPath") Bundle_bundleWithPath :: proc(path: ^String) -> ^Bundle { return msgSend(^Bundle, Bundle, "bundleWithPath:", path) } +@(objc_type=Bundle, objc_class_name="bundleWithURL") Bundle_bundleWithURL :: proc(url: ^URL) -> ^Bundle { return msgSend(^Bundle, Bundle, "bundleWithUrl:", url) } -Bundle_bundle :: proc{ - Bundle_bundleWithPath, - Bundle_bundleWithURL, + + +@(objc_type=Bundle, objc_class_name="alloc") +Bundle_alloc :: proc() -> ^Bundle { + return msgSend(^Bundle, Bundle, "alloc") } +@(objc_type=Bundle, objc_name="init") +Bundle_init :: proc(self: ^Bundle) -> ^Bundle { + return msgSend(^Bundle, self, "init") +} +@(objc_type=Bundle, objc_name="initWithPath") Bundle_initWithPath :: proc(self: ^Bundle, path: ^String) -> ^Bundle { return msgSend(^Bundle, self, "initWithPath:", path) } +@(objc_type=Bundle, objc_name="initWithURL") Bundle_initWithURL :: proc(self: ^Bundle, url: ^URL) -> ^Bundle { return msgSend(^Bundle, self, "initWithUrl:", url) } -Bundle_init :: proc{ - Bundle_initWithPath, - Bundle_initWithURL, -} - -Bundle_allBundles :: proc() -> (all: ^Array(^Bundle)) { +@(objc_type=Bundle, objc_name="allBundles") +Bundle_allBundles :: proc() -> (all: ^Array) { return msgSend(type_of(all), Bundle, "allBundles") } -Bundle_allFrameworks :: proc() -> (all: ^Array(^Object)) { +@(objc_type=Bundle, objc_name="allFrameworks") +Bundle_allFrameworks :: proc() -> (all: ^Array) { return msgSend(type_of(all), Bundle, "allFrameworks") } +@(objc_type=Bundle, objc_name="load") Bundle_load :: proc(self: ^Bundle) -> BOOL { return msgSend(BOOL, self, "load") } +@(objc_type=Bundle, objc_name="unload") Bundle_unload :: proc(self: ^Bundle) -> BOOL { return msgSend(BOOL, self, "unload") } +@(objc_type=Bundle, objc_name="isLoaded") Bundle_isLoaded :: proc(self: ^Bundle) -> BOOL { return msgSend(BOOL, self, "isLoaded") } +@(objc_type=Bundle, objc_name="preflightAndReturnError") Bundle_preflightAndReturnError :: proc(self: ^Bundle) -> (ok: BOOL, error: ^Error) { ok = msgSend(BOOL, self, "preflightAndReturnError:", &error) return } +@(objc_type=Bundle, objc_name="loadAndReturnError") Bundle_loadAndReturnError :: proc(self: ^Bundle) -> (ok: BOOL, error: ^Error) { ok = msgSend(BOOL, self, "loadAndReturnError:", &error) return } +@(objc_type=Bundle, objc_name="bundleURL") Bundle_bundleURL :: proc(self: ^Bundle) -> ^URL { return msgSend(^URL, self, "bundleURL") } +@(objc_type=Bundle, objc_name="resourceURL") Bundle_resourceURL :: proc(self: ^Bundle) -> ^URL { return msgSend(^URL, self, "resourceURL") } +@(objc_type=Bundle, objc_name="executableURL") Bundle_executableURL :: proc(self: ^Bundle) -> ^URL { return msgSend(^URL, self, "executableURL") } +@(objc_type=Bundle, objc_name="URLForAuxiliaryExecutable") Bundle_URLForAuxiliaryExecutable :: proc(self: ^Bundle, executableName: ^String) -> ^URL { return msgSend(^URL, self, "URLForAuxiliaryExecutable:", executableName) } +@(objc_type=Bundle, objc_name="privateFrameworksURL") Bundle_privateFrameworksURL :: proc(self: ^Bundle) -> ^URL { return msgSend(^URL, self, "privateFrameworksURL") } +@(objc_type=Bundle, objc_name="sharedFrameworksURL") Bundle_sharedFrameworksURL :: proc(self: ^Bundle) -> ^URL { return msgSend(^URL, self, "sharedFrameworksURL") } +@(objc_type=Bundle, objc_name="sharedSupportURL") Bundle_sharedSupportURL :: proc(self: ^Bundle) -> ^URL { return msgSend(^URL, self, "sharedSupportURL") } +@(objc_type=Bundle, objc_name="builtInPlugInsURL") Bundle_builtInPlugInsURL :: proc(self: ^Bundle) -> ^URL { return msgSend(^URL, self, "builtInPlugInsURL") } +@(objc_type=Bundle, objc_name="appStoreReceiptURL") Bundle_appStoreReceiptURL :: proc(self: ^Bundle) -> ^URL { return msgSend(^URL, self, "appStoreReceiptURL") } @@ -102,60 +124,74 @@ Bundle_appStoreReceiptURL :: proc(self: ^Bundle) -> ^URL { +@(objc_type=Bundle, objc_name="bundlePath") Bundle_bundlePath :: proc(self: ^Bundle) -> ^String { return msgSend(^String, self, "bundlePath") } +@(objc_type=Bundle, objc_name="resourcePath") Bundle_resourcePath :: proc(self: ^Bundle) -> ^String { return msgSend(^String, self, "resourcePath") } +@(objc_type=Bundle, objc_name="executablePath") Bundle_executablePath :: proc(self: ^Bundle) -> ^String { return msgSend(^String, self, "executablePath") } +@(objc_type=Bundle, objc_name="PathForAuxiliaryExecutable") Bundle_PathForAuxiliaryExecutable :: proc(self: ^Bundle, executableName: ^String) -> ^String { return msgSend(^String, self, "PathForAuxiliaryExecutable:", executableName) } +@(objc_type=Bundle, objc_name="privateFrameworksPath") Bundle_privateFrameworksPath :: proc(self: ^Bundle) -> ^String { return msgSend(^String, self, "privateFrameworksPath") } +@(objc_type=Bundle, objc_name="sharedFrameworksPath") Bundle_sharedFrameworksPath :: proc(self: ^Bundle) -> ^String { return msgSend(^String, self, "sharedFrameworksPath") } +@(objc_type=Bundle, objc_name="sharedSupportPath") Bundle_sharedSupportPath :: proc(self: ^Bundle) -> ^String { return msgSend(^String, self, "sharedSupportPath") } +@(objc_type=Bundle, objc_name="builtInPlugInsPath") Bundle_builtInPlugInsPath :: proc(self: ^Bundle) -> ^String { return msgSend(^String, self, "builtInPlugInsPath") } +@(objc_type=Bundle, objc_name="appStoreReceiptPath") Bundle_appStoreReceiptPath :: proc(self: ^Bundle) -> ^String { return msgSend(^String, self, "appStoreReceiptPath") } +@(objc_type=Bundle, objc_name="bundleIdentifier") Bundle_bundleIdentifier :: proc(self: ^Bundle) -> ^String { return msgSend(^String, self, "bundleIdentifier") } +@(objc_type=Bundle, objc_name="infoDictionary") Bundle_infoDictionary :: proc(self: ^Bundle) -> ^Dictionary { return msgSend(^Dictionary, self, "infoDictionary") } +@(objc_type=Bundle, objc_name="localizedInfoDictionary") Bundle_localizedInfoDictionary :: proc(self: ^Bundle) -> ^Dictionary { return msgSend(^Dictionary, self, "localizedInfoDictionary") } +@(objc_type=Bundle, objc_name="objectForInfoDictionaryKey") Bundle_objectForInfoDictionaryKey :: proc(self: ^Bundle, key: ^String) -> ^Object { return msgSend(^Object, self, "objectForInfoDictionaryKey:", key) } +@(objc_type=Bundle, objc_name="localizedStringForKey") Bundle_localizedStringForKey :: proc(self: ^Bundle, key: ^String, value: ^String = nil, tableName: ^String = nil) -> ^String { return msgSend(^String, self, "localizedStringForKey:value:table:", key, value, tableName) } diff --git a/core/sys/darwin/Foundation/NSData.odin b/core/sys/darwin/Foundation/NSData.odin index 93bb3ae0e..e28f6a644 100644 --- a/core/sys/darwin/Foundation/NSData.odin +++ b/core/sys/darwin/Foundation/NSData.odin @@ -3,10 +3,22 @@ package objc_Foundation @(objc_class="NSData") Data :: struct {using _: Copying(Data)} +@(objc_type=Data, objc_class_name="alloc") +Data_alloc :: proc() -> ^Data { + return msgSend(^Data, Data, "alloc") +} + +@(objc_type=Data, objc_name="init") +Data_init :: proc(self: ^Data) -> ^Data { + return msgSend(^Data, self, "init") +} + +@(objc_type=Data, objc_name="mutableBytes") Data_mutableBytes :: proc(self: ^Data) -> rawptr { return msgSend(rawptr, self, "mutableBytes") } +@(objc_type=Data, objc_name="length") Data_length :: proc(self: ^Data) -> UInteger { return msgSend(UInteger, self, "length") } \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSDate.odin b/core/sys/darwin/Foundation/NSDate.odin index 4b298ee24..85bb14c3e 100644 --- a/core/sys/darwin/Foundation/NSDate.odin +++ b/core/sys/darwin/Foundation/NSDate.odin @@ -3,6 +3,18 @@ package objc_Foundation @(objc_class="NSDate") Date :: struct {using _: Copying(Date)} +@(objc_type=Date, objc_class_name="alloc") +Date_alloc :: proc() -> ^Date { + return msgSend(^Date, Date, "alloc") +} + +@(objc_type=Date, objc_name="init") +Date_init :: proc(self: ^Date) -> ^Date { + return msgSend(^Date, self, "init") +} + + +@(objc_type=Date, objc_name="dateWithTimeIntervalSinceNow") Date_dateWithTimeIntervalSinceNow :: proc(secs: TimeInterval) -> ^Date { return msgSend(^Date, Date, "dateWithTimeIntervalSinceNow:", secs) } \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSDictionary.odin b/core/sys/darwin/Foundation/NSDictionary.odin index f82b8cffd..3eb378dc7 100644 --- a/core/sys/darwin/Foundation/NSDictionary.odin +++ b/core/sys/darwin/Foundation/NSDictionary.odin @@ -3,31 +3,49 @@ package objc_Foundation @(objc_class="NSDictionary") Dictionary :: struct {using _: Copying(Dictionary)} +@(objc_type=Dictionary, objc_class_name="dictionary") Dictionary_dictionary :: proc() -> ^Dictionary { return msgSend(^Dictionary, Dictionary, "dictionary") } +@(objc_type=Dictionary, objc_class_name="dictionaryWithObject") Dictionary_dictionaryWithObject :: proc(object: ^Object, forKey: ^Object) -> ^Dictionary { return msgSend(^Dictionary, Dictionary, "dictionaryWithObject:forKey:", object, forKey) } +@(objc_type=Dictionary, objc_class_name="dictionaryWithObjects") Dictionary_dictionaryWithObjects :: proc(objects: [^]^Object, forKeys: [^]^Object, count: UInteger) -> ^Dictionary { return msgSend(^Dictionary, Dictionary, "dictionaryWithObjects:forKeys:count", objects, forKeys, count) } +@(objc_type=Dictionary, objc_class_name="alloc") +Dictionary_alloc :: proc() -> ^Dictionary { + return msgSend(^Dictionary, Dictionary, "alloc") +} + +@(objc_type=Dictionary, objc_name="init") +Dictionary_init :: proc(self: ^Dictionary) -> ^Dictionary { + return msgSend(^Dictionary, self, "init") +} + + +@(objc_type=Dictionary, objc_name="initWithObjects") Dictionary_initWithObjects :: proc(self: ^Dictionary, objects: [^]^Object, forKeys: [^]^Object, count: UInteger) -> ^Dictionary { return msgSend(^Dictionary, self, "initWithObjects:forKeys:count", objects, forKeys, count) } +@(objc_type=Dictionary, objc_name="objectForKey") Dictionary_objectForKey :: proc(self: ^Dictionary, key: ^Object) -> ^Object { return msgSend(^Dictionary, self, "objectForKey:", key) } +@(objc_type=Dictionary, objc_name="count") Dictionary_count :: proc(self: ^Dictionary) -> UInteger { return msgSend(UInteger, self, "count") } +@(objc_type=Dictionary, objc_name="keyEnumerator") Dictionary_keyEnumerator :: proc(self: ^Dictionary, $KeyType: typeid) -> (enumerator: ^Enumerator(KeyType)) { return msgSend(type_of(enumerator), self, "keyEnumerator") } diff --git a/core/sys/darwin/Foundation/NSEnumerator.odin b/core/sys/darwin/Foundation/NSEnumerator.odin index b6adf2b98..8a5a32e69 100644 --- a/core/sys/darwin/Foundation/NSEnumerator.odin +++ b/core/sys/darwin/Foundation/NSEnumerator.odin @@ -18,6 +18,19 @@ Enumerator :: struct($T: typeid) where intrinsics.type_is_pointer(T), intrinsics using _: FastEnumeration, } + +@(objc_type=FastEnumeration, objc_class_name="alloc") +FastEnumeration_alloc :: proc() -> ^FastEnumeration { + return msgSend(^FastEnumeration, FastEnumeration, "alloc") +} + +@(objc_type=FastEnumeration, objc_name="init") +FastEnumeration_init :: proc(self: ^FastEnumeration) -> ^FastEnumeration { + return msgSend(^FastEnumeration, self, "init") +} + + +@(objc_type=FastEnumeration, objc_name="countByEnumerating") FastEnumeration_countByEnumerating :: proc(self: ^FastEnumeration, state: ^FastEnumerationState, buffer: [^]^Object, len: UInteger) -> UInteger { return msgSend(UInteger, self, "countByEnumeratingWithState:objects:count:", state, buffer, len) } @@ -26,7 +39,7 @@ Enumerator_nextObject :: proc(self: ^$E/Enumerator($T)) -> T { return msgSend(T, self, "nextObject") } -Enumerator_allObjects :: proc(self: ^$E/Enumerator($T)) -> (all: Array(T)) { +Enumerator_allObjects :: proc(self: ^$E/Enumerator($T)) -> (all: ^Array) { return msgSend(type_of(all), self, "allObjects") } diff --git a/core/sys/darwin/Foundation/NSError.odin b/core/sys/darwin/Foundation/NSError.odin index aebf01035..bff0088e9 100644 --- a/core/sys/darwin/Foundation/NSError.odin +++ b/core/sys/darwin/Foundation/NSError.odin @@ -31,38 +31,58 @@ foreign Foundation { @(objc_class="NSError") Error :: struct { using _: Copying(Error) } + +@(objc_type=Error, objc_class_name="alloc") +Error_alloc :: proc() -> ^Error { + return msgSend(^Error, Error, "alloc") +} + +@(objc_type=Error, objc_name="init") +Error_init :: proc(self: ^Error) -> ^Error { + return msgSend(^Error, self, "init") +} + +@(objc_type=Error, objc_class_name="errorWithDomain") Error_errorWithDomain :: proc(domain: ErrorDomain, code: Integer, userInfo: ^Dictionary) -> ^Error { return msgSend(^Error, Error, "errorWithDomain:code:userInfo:", domain, code, userInfo) } +@(objc_type=Error, objc_name="initWithDomain") Error_initWithDomain :: proc(self: ^Error, domain: ErrorDomain, code: Integer, userInfo: ^Dictionary) -> ^Error { return msgSend(^Error, self, "initWithDomain:code:userInfo:", domain, code, userInfo) } +@(objc_type=Error, objc_name="code") Error_code :: proc(self: ^Error) -> Integer { return msgSend(Integer, self, "code") } +@(objc_type=Error, objc_name="domain") Error_domain :: proc(self: ^Error) -> ErrorDomain { return msgSend(ErrorDomain, self, "domain") } +@(objc_type=Error, objc_name="userInfo") Error_userInfo :: proc(self: ^Error) -> ^Dictionary { return msgSend(^Dictionary, self, "userInfo") } +@(objc_type=Error, objc_name="localizedDescription") Error_localizedDescription :: proc(self: ^Error) -> ^String { return msgSend(^String, self, "localizedDescription") } -Error_localizedRecoveryOptions :: proc(self: ^Error) -> (options: ^Array(^Object)) { +@(objc_type=Error, objc_name="localizedRecoveryOptions") +Error_localizedRecoveryOptions :: proc(self: ^Error) -> (options: ^Array) { return msgSend(type_of(options), self, "localizedRecoveryOptions") } +@(objc_type=Error, objc_name="localizedRecoverySuggestion") Error_localizedRecoverySuggestion :: proc(self: ^Error) -> ^String { return msgSend(^String, self, "localizedRecoverySuggestion") } +@(objc_type=Error, objc_name="localizedFailureReason") Error_localizedFailureReason :: proc(self: ^Error) -> ^String { return msgSend(^String, self, "localizedFailureReason") } \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSLock.odin b/core/sys/darwin/Foundation/NSLock.odin index 0e76dfc62..3bcc06eab 100644 --- a/core/sys/darwin/Foundation/NSLock.odin +++ b/core/sys/darwin/Foundation/NSLock.odin @@ -12,18 +12,42 @@ Locking_unlock :: proc(self: ^Locking($T)) { @(objc_class="NSCondition") Condition :: struct {using _: Locking(Condition) } + +@(objc_type=Condition, objc_class_name="alloc") +Condition_alloc :: proc() -> ^Condition { + return msgSend(^Condition, Condition, "alloc") +} + +@(objc_type=Condition, objc_name="init") +Condition_init :: proc(self: ^Condition) -> ^Condition { + return msgSend(^Condition, self, "init") +} + +@(objc_type=Condition, objc_name="wait") Condition_wait :: proc(self: ^Condition) { msgSend(nil, self, "wait") } +@(objc_type=Condition, objc_name="waitUntilDate") Condition_waitUntilDate :: proc(self: ^Condition, limit: ^Date) -> BOOL { return msgSend(BOOL, self, "waitUntilDate:", limit) } +@(objc_type=Condition, objc_name="signal") Condition_signal :: proc(self: ^Condition) { msgSend(nil, self, "signal") } +@(objc_type=Condition, objc_name="broadcast") Condition_broadcast :: proc(self: ^Condition) { msgSend(nil, self, "broadcast") +} + +@(objc_type=Condition, objc_name="lock") +Condition_lock :: proc(self: ^Condition) { + msgSend(nil, self, "lock") +} +@(objc_type=Condition, objc_name="unlock") +Condition_unlock :: proc(self: ^Condition) { + msgSend(nil, self, "unlock") } \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSNotification.odin b/core/sys/darwin/Foundation/NSNotification.odin index fa9160cc8..d8b142e53 100644 --- a/core/sys/darwin/Foundation/NSNotification.odin +++ b/core/sys/darwin/Foundation/NSNotification.odin @@ -3,14 +3,29 @@ package objc_Foundation @(objc_class="NSNotification") Notification :: struct{using _: Object} + +@(objc_type=Notification, objc_class_name="alloc") +Notification_alloc :: proc() -> ^Notification { + return msgSend(^Notification, Notification, "alloc") +} + +@(objc_type=Notification, objc_name="init") +Notification_init :: proc(self: ^Notification) -> ^Notification { + return msgSend(^Notification, self, "init") +} + + +@(objc_type=Notification, objc_name="name") Notification_name :: proc(self: ^Notification) -> ^String { return msgSend(^String, self, "name") } +@(objc_type=Notification, objc_name="object") Notification_object :: proc(self: ^Notification) -> ^Object { return msgSend(^Object, self, "object") } +@(objc_type=Notification, objc_name="userInfo") Notification_userInfo :: proc(self: ^Notification) -> ^Dictionary { return msgSend(^Dictionary, self, "userInfo") } \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSNumber.odin b/core/sys/darwin/Foundation/NSNumber.odin index 2630e6daa..f77b0866a 100644 --- a/core/sys/darwin/Foundation/NSNumber.odin +++ b/core/sys/darwin/Foundation/NSNumber.odin @@ -8,35 +8,53 @@ import "core:c" @(objc_class="NSValue") Value :: struct{using _: Copying(Value)} +@(objc_type=Value, objc_class_name="alloc") +Value_alloc :: proc() -> ^Value { + return msgSend(^Value, Value, "alloc") +} + +@(objc_type=Value, objc_name="init") +Value_init :: proc(self: ^Value) -> ^Value { + return msgSend(^Value, self, "init") +} + +@(objc_type=Value, objc_class_name="valueWithBytes") Value_valueWithBytes :: proc(value: rawptr, type: cstring) -> ^Value { return msgSend(^Value, Value, "valueWithBytes:objCType:", value, type) } +@(objc_type=Value, objc_class_name="valueWithPointer") Value_valueWithPointer :: proc(pointer: rawptr) -> ^Value { return msgSend(^Value, Value, "valueWithPointer:", pointer) } +@(objc_type=Value, objc_name="initWithBytes") Value_initWithBytes :: proc(self: ^Value, value: rawptr, type: cstring) -> ^Value { return msgSend(^Value, self, "initWithBytes:objCType:", value, type) } -Value_initWithCoder :: proc(coder: ^Coder) -> ^Value { - return msgSend(^Value, Value, "initWithCoder:", coder) +@(objc_type=Value, objc_name="initWithCoder") +Value_initWithCoder :: proc(self: ^Value, coder: ^Coder) -> ^Value { + return msgSend(^Value, self, "initWithCoder:", coder) } +@(objc_type=Value, objc_name="getValue") Value_getValue :: proc(self: ^Value, value: rawptr, size: UInteger) { msgSend(nil, self, "getValue:size:", value, size) } +@(objc_type=Value, objc_name="objCType") Value_objCType :: proc(self: ^Value) -> cstring { return msgSend(cstring, self, "objCType") } +@(objc_type=Value, objc_name="isEqualToValue") Value_isEqualToValue :: proc(self, other: ^Value) -> BOOL { return msgSend(BOOL, self, "isEqualToValue:", other) } +@(objc_type=Value, objc_name="pointerValue") Value_pointerValue :: proc(self: ^Value) -> rawptr { return msgSend(rawptr, self, "pointerValue") } @@ -46,19 +64,29 @@ Value_pointerValue :: proc(self: ^Value) -> rawptr { Number :: struct{using _: Copying(Number), using _: Value} -Number_numberWithI8 :: proc(value: i8) -> ^Number { return msgSend(^Number, Number, "numberWithChar:", value) } -Number_numberWithU8 :: proc(value: u8) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedChar:", value) } -Number_numberWithI16 :: proc(value: i16) -> ^Number { return msgSend(^Number, Number, "numberWithShort:", value) } -Number_numberWithU16 :: proc(value: u16) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedShort:", value) } -Number_numberWithI32 :: proc(value: i32) -> ^Number { return msgSend(^Number, Number, "numberWithInt:", value) } -Number_numberWithU32 :: proc(value: u32) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedInt:", value) } -Number_numberWithInt :: proc(value: int) -> ^Number { return msgSend(^Number, Number, "numberWithLong:", value) } -Number_numberWithUint :: proc(value: uint) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLong:", value) } -Number_numberWithU64 :: proc(value: u64) -> ^Number { return msgSend(^Number, Number, "numberWithLongLong:", value) } -Number_numberWithI64 :: proc(value: i64) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLongLong:", value) } -Number_numberWithF32 :: proc(value: f32) -> ^Number { return msgSend(^Number, Number, "numberWithFloat:", value) } -Number_numberWithF64 :: proc(value: f64) -> ^Number { return msgSend(^Number, Number, "numberWithDouble:", value) } -Number_numberWithBool :: proc(value: BOOL) -> ^Number { return msgSend(^Number, Number, "numberWithBool:", value) } +@(objc_type=Number, objc_class_name="alloc") +Number_alloc :: proc() -> ^Number { + return msgSend(^Number, Number, "alloc") +} + +@(objc_type=Number, objc_name="init") +Number_init :: proc(self: ^Number) -> ^Number { + return msgSend(^Number, self, "init") +} + +@(objc_type=Number, objc_class_name="numberWithI8") Number_numberWithI8 :: proc(value: i8) -> ^Number { return msgSend(^Number, Number, "numberWithChar:", value) } +@(objc_type=Number, objc_class_name="numberWithU8") Number_numberWithU8 :: proc(value: u8) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedChar:", value) } +@(objc_type=Number, objc_class_name="numberWithI16") Number_numberWithI16 :: proc(value: i16) -> ^Number { return msgSend(^Number, Number, "numberWithShort:", value) } +@(objc_type=Number, objc_class_name="numberWithU16") Number_numberWithU16 :: proc(value: u16) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedShort:", value) } +@(objc_type=Number, objc_class_name="numberWithI32") Number_numberWithI32 :: proc(value: i32) -> ^Number { return msgSend(^Number, Number, "numberWithInt:", value) } +@(objc_type=Number, objc_class_name="numberWithU32") Number_numberWithU32 :: proc(value: u32) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedInt:", value) } +@(objc_type=Number, objc_class_name="numberWithInt") Number_numberWithInt :: proc(value: int) -> ^Number { return msgSend(^Number, Number, "numberWithLong:", value) } +@(objc_type=Number, objc_class_name="numberWithUint") Number_numberWithUint :: proc(value: uint) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLong:", value) } +@(objc_type=Number, objc_class_name="numberWithU64") Number_numberWithU64 :: proc(value: u64) -> ^Number { return msgSend(^Number, Number, "numberWithLongLong:", value) } +@(objc_type=Number, objc_class_name="numberWithI64") Number_numberWithI64 :: proc(value: i64) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLongLong:", value) } +@(objc_type=Number, objc_class_name="numberWithF32") Number_numberWithF32 :: proc(value: f32) -> ^Number { return msgSend(^Number, Number, "numberWithFloat:", value) } +@(objc_type=Number, objc_class_name="numberWithF64") Number_numberWithF64 :: proc(value: f64) -> ^Number { return msgSend(^Number, Number, "numberWithDouble:", value) } +@(objc_type=Number, objc_class_name="numberWithBool") Number_numberWithBool :: proc(value: BOOL) -> ^Number { return msgSend(^Number, Number, "numberWithBool:", value) } Number_number :: proc{ Number_numberWithI8, @@ -76,62 +104,49 @@ Number_number :: proc{ Number_numberWithBool, } -Number_initWithI8 :: proc(self: ^Number, value: i8) -> ^Number { return msgSend(^Number, self, "initWithChar:", value) } -Number_initWithU8 :: proc(self: ^Number, value: u8) -> ^Number { return msgSend(^Number, self, "initWithUnsignedChar:", value) } -Number_initWithI16 :: proc(self: ^Number, value: i16) -> ^Number { return msgSend(^Number, self, "initWithShort:", value) } -Number_initWithU16 :: proc(self: ^Number, value: u16) -> ^Number { return msgSend(^Number, self, "initWithUnsignedShort:", value) } -Number_initWithI32 :: proc(self: ^Number, value: i32) -> ^Number { return msgSend(^Number, self, "initWithInt:", value) } -Number_initWithU32 :: proc(self: ^Number, value: u32) -> ^Number { return msgSend(^Number, self, "initWithUnsignedInt:", value) } -Number_initWithInt :: proc(self: ^Number, value: int) -> ^Number { return msgSend(^Number, self, "initWithLong:", value) } -Number_initWithUint :: proc(self: ^Number, value: uint) -> ^Number { return msgSend(^Number, self, "initWithUnsignedLong:", value) } -Number_initWithU64 :: proc(self: ^Number, value: u64) -> ^Number { return msgSend(^Number, self, "initWithLongLong:", value) } -Number_initWithI64 :: proc(self: ^Number, value: i64) -> ^Number { return msgSend(^Number, self, "initWithUnsignedLongLong:", value) } -Number_initWithF32 :: proc(self: ^Number, value: f32) -> ^Number { return msgSend(^Number, self, "initWithFloat:", value) } -Number_initWithF64 :: proc(self: ^Number, value: f64) -> ^Number { return msgSend(^Number, self, "initWithDouble:", value) } -Number_initWithBool :: proc(self: ^Number, value: BOOL) -> ^Number { return msgSend(^Number, self, "initWithBool:", value) } +@(objc_type=Number, objc_name="initWithI8") Number_initWithI8 :: proc(self: ^Number, value: i8) -> ^Number { return msgSend(^Number, self, "initWithChar:", value) } +@(objc_type=Number, objc_name="initWithU8") Number_initWithU8 :: proc(self: ^Number, value: u8) -> ^Number { return msgSend(^Number, self, "initWithUnsignedChar:", value) } +@(objc_type=Number, objc_name="initWithI16") Number_initWithI16 :: proc(self: ^Number, value: i16) -> ^Number { return msgSend(^Number, self, "initWithShort:", value) } +@(objc_type=Number, objc_name="initWithU16") Number_initWithU16 :: proc(self: ^Number, value: u16) -> ^Number { return msgSend(^Number, self, "initWithUnsignedShort:", value) } +@(objc_type=Number, objc_name="initWithI32") Number_initWithI32 :: proc(self: ^Number, value: i32) -> ^Number { return msgSend(^Number, self, "initWithInt:", value) } +@(objc_type=Number, objc_name="initWithU32") Number_initWithU32 :: proc(self: ^Number, value: u32) -> ^Number { return msgSend(^Number, self, "initWithUnsignedInt:", value) } +@(objc_type=Number, objc_name="initWithInt") Number_initWithInt :: proc(self: ^Number, value: int) -> ^Number { return msgSend(^Number, self, "initWithLong:", value) } +@(objc_type=Number, objc_name="initWithUint") Number_initWithUint :: proc(self: ^Number, value: uint) -> ^Number { return msgSend(^Number, self, "initWithUnsignedLong:", value) } +@(objc_type=Number, objc_name="initWithU64") Number_initWithU64 :: proc(self: ^Number, value: u64) -> ^Number { return msgSend(^Number, self, "initWithLongLong:", value) } +@(objc_type=Number, objc_name="initWithI64") Number_initWithI64 :: proc(self: ^Number, value: i64) -> ^Number { return msgSend(^Number, self, "initWithUnsignedLongLong:", value) } +@(objc_type=Number, objc_name="initWithF32") Number_initWithF32 :: proc(self: ^Number, value: f32) -> ^Number { return msgSend(^Number, self, "initWithFloat:", value) } +@(objc_type=Number, objc_name="initWithF64") Number_initWithF64 :: proc(self: ^Number, value: f64) -> ^Number { return msgSend(^Number, self, "initWithDouble:", value) } +@(objc_type=Number, objc_name="initWithBool") Number_initWithBool :: proc(self: ^Number, value: BOOL) -> ^Number { return msgSend(^Number, self, "initWithBool:", value) } -Number_init :: proc{ - Number_initWithI8, - Number_initWithU8, - Number_initWithI16, - Number_initWithU16, - Number_initWithI32, - Number_initWithU32, - Number_initWithInt, - Number_initWithUint, - Number_initWithU64, - Number_initWithI64, - Number_initWithF32, - Number_initWithF64, - Number_initWithBool, +@(objc_type=Number, objc_name="i8Value") Number_i8Value :: proc(self: ^Number) -> i8 { return msgSend(i8, self, "charValue") } +@(objc_type=Number, objc_name="u8Value") Number_u8Value :: proc(self: ^Number) -> u8 { return msgSend(u8, self, "unsignedCharValue") } +@(objc_type=Number, objc_name="i16Value") Number_i16Value :: proc(self: ^Number) -> i16 { return msgSend(i16, self, "shortValue") } +@(objc_type=Number, objc_name="u16Value") Number_u16Value :: proc(self: ^Number) -> u16 { return msgSend(u16, self, "unsignedShortValue") } +@(objc_type=Number, objc_name="i32Value") Number_i32Value :: proc(self: ^Number) -> i32 { return msgSend(i32, self, "intValue") } +@(objc_type=Number, objc_name="u32Value") Number_u32Value :: proc(self: ^Number) -> u32 { return msgSend(u32, self, "unsignedIntValue") } +@(objc_type=Number, objc_name="intValue") Number_intValue :: proc(self: ^Number) -> int { return msgSend(int, self, "longValue") } +@(objc_type=Number, objc_name="uintValue") Number_uintValue :: proc(self: ^Number) -> uint { return msgSend(uint, self, "unsignedLongValue") } +@(objc_type=Number, objc_name="u64Value") Number_u64Value :: proc(self: ^Number) -> u64 { return msgSend(u64, self, "longLongValue") } +@(objc_type=Number, objc_name="i64Value") Number_i64Value :: proc(self: ^Number) -> i64 { return msgSend(i64, self, "unsignedLongLongValue") } +@(objc_type=Number, objc_name="f32Value") Number_f32Value :: proc(self: ^Number) -> f32 { return msgSend(f32, self, "floatValue") } +@(objc_type=Number, objc_name="f64Value") Number_f64Value :: proc(self: ^Number) -> f64 { return msgSend(f64, self, "doubleValue") } +@(objc_type=Number, objc_name="boolValue") Number_boolValue :: proc(self: ^Number) -> BOOL { return msgSend(BOOL, self, "boolValue") } +@(objc_type=Number, objc_name="integerValue") Number_integerValue :: proc(self: ^Number) -> Integer { return msgSend(Integer, self, "integerValue") } +@(objc_type=Number, objc_name="uintegerValue") Number_uintegerValue :: proc(self: ^Number) -> UInteger { return msgSend(UInteger, self, "unsignedIntegerValue") } +@(objc_type=Number, objc_name="stringValue") Number_stringValue :: proc(self: ^Number) -> ^String { return msgSend(^String, self, "stringValue") } + +@(objc_type=Number, objc_name="compare") +Number_compare :: proc(self, other: ^Number) -> ComparisonResult { + return msgSend(ComparisonResult, self, "compare:", other) } -Number_i8Value :: proc(self: ^Number) -> i8 { return msgSend(i8, self, "charValue") } -Number_u8Value :: proc(self: ^Number) -> u8 { return msgSend(u8, self, "unsignedCharValue") } -Number_i16Value :: proc(self: ^Number) -> i16 { return msgSend(i16, self, "shortValue") } -Number_u16Value :: proc(self: ^Number) -> u16 { return msgSend(u16, self, "unsignedShortValue") } -Number_i32Value :: proc(self: ^Number) -> i32 { return msgSend(i32, self, "intValue") } -Number_u32Value :: proc(self: ^Number) -> u32 { return msgSend(u32, self, "unsignedIntValue") } -Number_intValue :: proc(self: ^Number) -> int { return msgSend(int, self, "longValue") } -Number_uintValue :: proc(self: ^Number) -> uint { return msgSend(uint, self, "unsignedLongValue") } -Number_u64Value :: proc(self: ^Number) -> u64 { return msgSend(u64, self, "longLongValue") } -Number_i64Value :: proc(self: ^Number) -> i64 { return msgSend(i64, self, "unsignedLongLongValue") } -Number_f32Value :: proc(self: ^Number) -> f32 { return msgSend(f32, self, "floatValue") } -Number_f64Value :: proc(self: ^Number) -> f64 { return msgSend(f64, self, "doubleValue") } -Number_boolValue :: proc(self: ^Number) -> BOOL { return msgSend(BOOL, self, "boolValue") } -Number_integerValue :: proc(self: ^Number) -> Integer { return msgSend(Integer, self, "integerValue") } -Number_uintegerValue :: proc(self: ^Number) -> UInteger { return msgSend(UInteger, self, "unsignedIntegerValue") } -Number_stringValue :: proc(self: ^Number) -> ^String { return msgSend(^String, self, "stringValue") } - -Number_compare :: proc(a, b: ^Number) -> ComparisonResult { - return msgSend(ComparisonResult, a, "compare:", b) -} - -Number_isEqualToNumber :: proc(a, b: ^Number) -> BOOL { - return msgSend(BOOL, a, "isEqualToNumber:", b) +@(objc_type=Number, objc_name="isEqualToNumber") +Number_isEqualToNumber :: proc(self, other: ^Number) -> BOOL { + return msgSend(BOOL, self, "isEqualToNumber:", other) } +@(objc_type=Number, objc_name="descriptionWithLocale") Number_descriptionWithLocale :: proc(self: ^Number, locale: ^Object) -> ^String { return msgSend(^String, self, "descriptionWithLocale:", locale) } \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSObject.odin b/core/sys/darwin/Foundation/NSObject.odin index d61f8e947..cd0919edd 100644 --- a/core/sys/darwin/Foundation/NSObject.odin +++ b/core/sys/darwin/Foundation/NSObject.odin @@ -27,37 +27,45 @@ alloc :: proc($T: typeid) -> ^T where intrinsics.type_is_subtype_of(T, Object) { init :: proc(self: ^$T) -> ^T where intrinsics.type_is_subtype_of(T, Object) { return msgSend(^T, self, "init") } -retain :: proc(self: ^$T) -> ^T where intrinsics.type_is_subtype_of(T, Object) { - return msgSend(^T, self, "retain") -} -release :: proc(self: ^$T) where intrinsics.type_is_subtype_of(T, Object) { - msgSend(nil, self, "release") -} -autorelease :: proc(self: ^$T) where intrinsics.type_is_subtype_of(T, Object) { - msgSend(nil, self, "autorelease") -} -retainCount :: proc(self: ^$T) -> UInteger where intrinsics.type_is_subtype_of(T, Object) { - return msgSend(UInteger, self, "retainCount") -} - - copy :: proc(self: ^Copying($T)) -> ^T where intrinsics.type_is_subtype_of(T, Object) { return msgSend(^T, self, "copy") } +@(objc_type=Object, objc_name="retain") +retain :: proc(self: ^Object) { + _ = msgSend(^Object, self, "retain") +} +@(objc_type=Object, objc_name="release") +release :: proc(self: ^Object) { + msgSend(nil, self, "release") +} +@(objc_type=Object, objc_name="autorelease") +autorelease :: proc(self: ^Object) { + msgSend(nil, self, "autorelease") +} +@(objc_type=Object, objc_name="retainCount") +retainCount :: proc(self: ^Object) -> UInteger { + return msgSend(UInteger, self, "retainCount") +} + + +@(objc_type=Object, objc_name="hash") hash :: proc(self: ^Object) -> UInteger { return msgSend(UInteger, self, "hash") } +@(objc_type=Object, objc_name="isEqual") isEqual :: proc(self, pObject: ^Object) -> BOOL { return msgSend(BOOL, self, "isEqual:", pObject) } +@(objc_type=Object, objc_name="description") description :: proc(self: ^Object) -> ^String { return msgSend(^String, self, "description") } +@(objc_type=Object, objc_name="debugDescription") debugDescription :: proc(self: ^Object) -> ^String { if msgSendSafeCheck(self, intrinsics.objc_selector_name("debugDescription")) { return msgSend(^String, self, "debugDescription") diff --git a/core/sys/darwin/Foundation/NSString.odin b/core/sys/darwin/Foundation/NSString.odin index 86c8cabea..06dbc27a3 100644 --- a/core/sys/darwin/Foundation/NSString.odin +++ b/core/sys/darwin/Foundation/NSString.odin @@ -59,54 +59,78 @@ MakeConstantString :: proc "c" (#const c: cstring) -> ^String { } +@(objc_type=String, objc_class_name="alloc") +String_alloc :: proc() -> ^String { + return msgSend(^String, String, "alloc") +} + +@(objc_type=String, objc_name="init") +String_init :: proc(self: ^String) -> ^String { + return msgSend(^String, self, "init") +} + + +@(objc_type=String, objc_name="initWithString") String_initWithString :: proc(self: ^String, other: ^String) -> ^String { return msgSend(^String, self, "initWithString:", other) } +@(objc_type=String, objc_name="initWithCString") String_initWithCString :: proc(self: ^String, pString: cstring, encoding: StringEncoding) -> ^String { return msgSend(^String, self, "initWithCstring:encoding:", pString, encoding) } +@(objc_type=String, objc_name="initWithBytesNoCopy") String_initWithBytesNoCopy :: proc(self: ^String, pBytes: rawptr, length: UInteger, encoding: StringEncoding, freeWhenDone: bool) -> ^String { return msgSend(^String, self, "initWithBytesNoCopy:length:encoding:freeWhenDone:", pBytes, length, encoding, freeWhenDone) } +@(objc_type=String, objc_name="initWithOdinString") String_initWithOdinString :: proc(self: ^String, str: string) -> ^String { return String_initWithBytesNoCopy(self, raw_data(str), UInteger(len(str)), .UTF8, false) } +@(objc_type=String, objc_name="characterAtIndex") String_characterAtIndex :: proc(self: ^String, index: UInteger) -> unichar { return msgSend(unichar, self, "characterAtIndex:", index) } +@(objc_type=String, objc_name="length") String_length :: proc(self: ^String) -> UInteger { return msgSend(UInteger, self, "length") } +@(objc_type=String, objc_name="cStringUsingEncoding") String_cStringUsingEncoding :: proc(self: ^String, encoding: StringEncoding) -> cstring { return msgSend(cstring, self, "cStringUsingEncoding:", encoding) } +@(objc_type=String, objc_name="UTF8String") String_UTF8String :: proc(self: ^String) -> cstring { return msgSend(cstring, self, "UTF8String") } +@(objc_type=String, objc_name="OdinString") String_OdinString :: proc(self: ^String) -> string { return string(String_UTF8String(self)) } +@(objc_type=String, objc_name="maximumLengthOfBytesUsingEncoding") String_maximumLengthOfBytesUsingEncoding :: proc(self: ^String, encoding: StringEncoding) -> UInteger { return msgSend(UInteger, self, "maximumLengthOfBytesUsingEncoding:", encoding) } +@(objc_type=String, objc_name="lengthOfBytesUsingEncoding") String_lengthOfBytesUsingEncoding :: proc(self: ^String, encoding: StringEncoding) -> UInteger { return msgSend(UInteger, self, "lengthOfBytesUsingEncoding:", encoding) } +@(objc_type=String, objc_name="isEqualToString") String_isEqualToString :: proc(self, other: ^String) -> BOOL { return msgSend(BOOL, self, "isEqualToString:", other) } +@(objc_type=String, objc_name="rangeOfString") String_rangeOfString :: proc(self, other: ^String, options: StringCompareOptions) -> Range { return msgSend(Range, self, "rangeOfString:options:", other, options) } \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSURL.odin b/core/sys/darwin/Foundation/NSURL.odin index f4f776130..42edf91c0 100644 --- a/core/sys/darwin/Foundation/NSURL.odin +++ b/core/sys/darwin/Foundation/NSURL.odin @@ -3,6 +3,18 @@ package objc_Foundation @(objc_class="NSURL") URL :: struct{using _: Copying(URL)} + +@(objc_type=URL, objc_class_name="alloc") +URL_alloc :: proc() -> ^URL { + return msgSend(^URL, URL, "alloc") +} + +@(objc_type=URL, objc_name="init") +URL_init :: proc(self: ^URL) -> ^URL { + return msgSend(^URL, self, "init") +} + + URL_initWithString :: proc(self: ^URL, value: ^String) -> ^URL { return msgSend(^URL, self, "initWithString:", value) } diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp index df22d82e2..a9ee5d25f 100644 --- a/src/check_builtin.cpp +++ b/src/check_builtin.cpp @@ -287,15 +287,13 @@ bool check_builtin_objc_procedure(CheckerContext *c, Operand *operand, Ast *call Operand self = {}; check_expr_or_type(c, &self, ce->args[1]); if (self.mode == Addressing_Type) { - if (!internal_check_is_assignable_to(self.type, t_objc_object)) { + if (!is_type_objc_object(self.type)) { gbString t = type_to_string(self.type); error(self.expr, "'%.*s' expected a type or value derived from intrinsics.objc_object, got type %s", LIT(builtin_name), t); gb_string_free(t); return false; } - if (!(self.type->kind == Type_Named && - self.type->Named.type_name != nullptr && - self.type->Named.type_name->TypeName.objc_class_name != "")) { + if (!has_type_got_objc_class_attribute(self.type)) { gbString t = type_to_string(self.type); error(self.expr, "'%.*s' expected a named type with the attribute @(obj_class=) , got type %s", LIT(builtin_name), t); gb_string_free(t); @@ -306,7 +304,7 @@ bool check_builtin_objc_procedure(CheckerContext *c, Operand *operand, Ast *call } else if (!is_operand_value(self) || !check_is_assignable_to(c, &self, t_objc_id)) { gbString e = expr_to_string(self.expr); gbString t = type_to_string(self.type); - error(self.expr, "'%.*s'3 expected a type or value derived from intrinsics.objc_object, got '%s' of type %s %d", LIT(builtin_name), e, t, self.type->kind); + error(self.expr, "'%.*s' expected a type or value derived from intrinsics.objc_object, got '%s' of type %s %d", LIT(builtin_name), e, t, self.type->kind); gb_string_free(t); gb_string_free(e); return false; diff --git a/src/check_decl.cpp b/src/check_decl.cpp index 243dbbbc6..1d30088d6 100644 --- a/src/check_decl.cpp +++ b/src/check_decl.cpp @@ -340,6 +340,10 @@ void check_type_decl(CheckerContext *ctx, Entity *e, Ast *init_expr, Type *def) check_decl_attributes(ctx, decl->attributes, type_decl_attribute, &ac); if (e->kind == Entity_TypeName && ac.objc_class != "") { e->TypeName.objc_class_name = ac.objc_class; + + if (type_size_of(e->type) > 0) { + error(e->token, "@(objc_class) marked type must be of zero size"); + } } } @@ -822,6 +826,65 @@ void check_proc_decl(CheckerContext *ctx, Entity *e, DeclInfo *d) { } e->Procedure.optimization_mode = cast(ProcedureOptimizationMode)ac.optimization_mode; + if (ac.objc_name.len || ac.objc_class_name.len || ac.objc_type) { + if (ac.objc_class_name.len && ac.objc_name.len) { + error(e->token, "@(objc_class_name) and @(objc_name) may not be allowed at the same time"); + } else if (ac.objc_type == nullptr) { + if (ac.objc_name.len) { + error(e->token, "@(objc_name) requires that @(objc_type) to be set"); + } else { + error(e->token, "@(objc_class_name) requires that @(objc_type) to be set"); + } + } else { + Type *t = ac.objc_type; + if (t->kind == Type_Named) { + Entity *tn = t->Named.type_name; + + GB_ASSERT(tn->kind == Entity_TypeName); + + if (tn->scope != e->scope) { + error(e->token, "@(objc_name) and @(objc_class_name) attributes may only be applied to procedures and types within the same scope"); + } else { + mutex_lock(&global_type_name_objc_metadata_mutex); + defer (mutex_unlock(&global_type_name_objc_metadata_mutex)); + + if (!tn->TypeName.objc_metadata) { + tn->TypeName.objc_metadata = create_type_name_obj_c_metadata(); + } + auto *md = tn->TypeName.objc_metadata; + mutex_lock(md->mutex); + defer (mutex_unlock(md->mutex)); + + if (ac.objc_name.len) { + bool ok = true; + for (TypeNameObjCMetadataEntry const &entry : md->value_entries) { + if (entry.name == ac.objc_name) { + error(e->token, "Previous declaration of @(objc_name=\"%.*s\")", LIT(ac.objc_name)); + ok = false; + break; + } + } + if (ok) { + array_add(&md->value_entries, TypeNameObjCMetadataEntry{ac.objc_name, e}); + } + } else { + bool ok = true; + for (TypeNameObjCMetadataEntry const &entry : md->type_entries) { + if (entry.name == ac.objc_class_name) { + error(e->token, "Previous declaration of @(objc_class_name=\"%.*s\")", LIT(ac.objc_class_name)); + ok = false; + break; + } + } + if (ok) { + array_add(&md->type_entries, TypeNameObjCMetadataEntry{ac.objc_class_name, e}); + } + } + } + } + } + } + switch (e->Procedure.optimization_mode) { case ProcedureOptimizationMode_None: diff --git a/src/check_type.cpp b/src/check_type.cpp index e1a0df7e6..32340070e 100644 --- a/src/check_type.cpp +++ b/src/check_type.cpp @@ -325,6 +325,8 @@ void add_polymorphic_record_entity(CheckerContext *ctx, Ast *node, Type *named_t named_type->Named.type_name = e; GB_ASSERT(original_type->kind == Type_Named); e->TypeName.objc_class_name = original_type->Named.type_name->TypeName.objc_class_name; + // TODO(bill): Is this even correct? Or should the metadata be copied? + e->TypeName.objc_metadata = original_type->Named.type_name->TypeName.objc_metadata; mutex_lock(&ctx->info->gen_types_mutex); auto *found_gen_types = map_get(&ctx->info->gen_types, original_type); diff --git a/src/checker.cpp b/src/checker.cpp index 2ab487592..0dd36987e 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -4,7 +4,7 @@ void check_expr(CheckerContext *c, Operand *operand, Ast *expression); void check_expr_or_type(CheckerContext *c, Operand *operand, Ast *expression, Type *type_hint=nullptr); void add_comparison_procedures_for_fields(CheckerContext *c, Type *t); - +Type *check_type(CheckerContext *ctx, Ast *e); bool is_operand_value(Operand o) { switch (o.mode) { @@ -2740,6 +2740,14 @@ ExactValue check_decl_attribute_value(CheckerContext *c, Ast *value) { return ev; } +Type *check_decl_attribute_type(CheckerContext *c, Ast *value) { + if (value != nullptr) { + return check_type(c, value); + } + return nullptr; +} + + #define ATTRIBUTE_USER_TAG_NAME "tag" @@ -3039,6 +3047,46 @@ DECL_ATTRIBUTE_PROC(proc_decl_attribute) { error(elem, "Expected a string for '%.*s'", LIT(name)); } return true; + } else if (name == "objc_name") { + ExactValue ev = check_decl_attribute_value(c, value); + if (ev.kind == ExactValue_String) { + if (string_is_valid_identifier(ev.value_string)) { + ac->objc_name = ev.value_string; + } else { + error(elem, "Invalid identifier for '%.*s', got '%.*s'", LIT(name), LIT(ev.value_string)); + } + } else { + error(elem, "Expected a string value for '%.*s'", LIT(name)); + } + return true; + } else if (name == "objc_class_name") { + ExactValue ev = check_decl_attribute_value(c, value); + if (ev.kind == ExactValue_String) { + if (string_is_valid_identifier(ev.value_string)) { + ac->objc_class_name = ev.value_string; + } else { + error(elem, "Invalid identifier for '%.*s', got '%.*s'", LIT(name), LIT(ev.value_string)); + } + } else { + error(elem, "Expected a string value for '%.*s'", LIT(name)); + } + return true; + } else if (name == "objc_type") { + if (value == nullptr) { + error(elem, "Expected a type for '%.*s'", LIT(name)); + } else { + Type *objc_type = check_type(c, value); + if (objc_type != nullptr) { + if (!has_type_got_objc_class_attribute(objc_type)) { + gbString t = type_to_string(objc_type); + error(value, "'%.*s' expected a named type with the attribute @(obj_class=), got type %s", LIT(name), t); + gb_string_free(t); + } else { + ac->objc_type = objc_type; + } + } + } + return true; } return false; } diff --git a/src/checker.hpp b/src/checker.hpp index b812e10a4..38c8d32f6 100644 --- a/src/checker.hpp +++ b/src/checker.hpp @@ -107,7 +107,6 @@ struct AttributeContext { String thread_local_model; String deprecated_message; String warning_message; - String objc_class; DeferredProcedure deferred_procedure; bool is_export : 1; bool is_static : 1; @@ -119,6 +118,11 @@ struct AttributeContext { bool init : 1; bool set_cold : 1; u32 optimization_mode; // ProcedureOptimizationMode + + String objc_class; + String objc_name; + String objc_class_name; + Type * objc_type; }; AttributeContext make_attribute_context(String link_prefix) { diff --git a/src/entity.cpp b/src/entity.cpp index 4d5b3b9e1..df8ee3faa 100644 --- a/src/entity.cpp +++ b/src/entity.cpp @@ -122,6 +122,28 @@ enum ProcedureOptimizationMode : u32 { ProcedureOptimizationMode_Speed, }; + +BlockingMutex global_type_name_objc_metadata_mutex; + +struct TypeNameObjCMetadataEntry { + String name; + Entity *entity; +}; +struct TypeNameObjCMetadata { + BlockingMutex *mutex; + Array type_entries; + Array value_entries; +}; + +TypeNameObjCMetadata *create_type_name_obj_c_metadata() { + TypeNameObjCMetadata *md = gb_alloc_item(permanent_allocator(), TypeNameObjCMetadata); + md->mutex = gb_alloc_item(permanent_allocator(), BlockingMutex); + mutex_init(md->mutex); + array_init(&md->type_entries, heap_allocator()); + array_init(&md->value_entries, heap_allocator()); + return md; +} + // An Entity is a named "thing" in the language struct Entity { EntityKind kind; @@ -187,6 +209,7 @@ struct Entity { String ir_mangled_name; bool is_type_alias; String objc_class_name; + TypeNameObjCMetadata *objc_metadata; } TypeName; struct { u64 tags; diff --git a/src/llvm_backend_expr.cpp b/src/llvm_backend_expr.cpp index 29a86d116..b2f430cd2 100644 --- a/src/llvm_backend_expr.cpp +++ b/src/llvm_backend_expr.cpp @@ -3320,7 +3320,12 @@ lbAddr lb_build_addr(lbProcedure *p, Ast *expr) { Type *type = base_type(tav.type); if (tav.mode == Addressing_Type) { // Addressing_Type - GB_PANIC("Unreachable"); + Selection sel = lookup_field(tav.type, selector, true); + if (sel.pseudo_field) { + GB_ASSERT(sel.entity->kind == Entity_Procedure); + return lb_addr(lb_find_value_from_entity(p->module, sel.entity)); + } + GB_PANIC("Unreachable %.*s", LIT(selector)); } if (se->swizzle_count > 0) { @@ -3347,6 +3352,10 @@ lbAddr lb_build_addr(lbProcedure *p, Ast *expr) { Selection sel = lookup_field(type, selector, false); GB_ASSERT(sel.entity != nullptr); + if (sel.pseudo_field) { + GB_ASSERT(sel.entity->kind == Entity_Procedure); + return lb_addr(lb_find_value_from_entity(p->module, sel.entity)); + } { lbAddr addr = lb_build_addr(p, se->expr); diff --git a/src/main.cpp b/src/main.cpp index fe56d451f..bd06193bd 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -585,37 +585,6 @@ void usage(String argv0) { print_usage_line(1, "e.g. odin build -help"); } - -bool string_is_valid_identifier(String str) { - if (str.len <= 0) return false; - - isize rune_count = 0; - - isize w = 0; - isize offset = 0; - while (offset < str.len) { - Rune r = 0; - w = utf8_decode(str.text, str.len, &r); - if (r == GB_RUNE_INVALID) { - return false; - } - - if (rune_count == 0) { - if (!rune_is_letter(r)) { - return false; - } - } else { - if (!rune_is_letter(r) && !rune_is_digit(r)) { - return false; - } - } - rune_count += 1; - offset += w; - } - - return true; -} - enum BuildFlagKind { BuildFlag_Invalid, @@ -2447,6 +2416,7 @@ int main(int arg_count, char const **arg_ptr) { virtual_memory_init(); mutex_init(&fullpath_mutex); mutex_init(&hash_exact_value_mutex); + mutex_init(&global_type_name_objc_metadata_mutex); init_string_buffer_memory(); init_string_interner(); diff --git a/src/string.cpp b/src/string.cpp index eb6058f78..bcaf23b9b 100644 --- a/src/string.cpp +++ b/src/string.cpp @@ -781,3 +781,34 @@ i32 unquote_string(gbAllocator a, String *s_, u8 quote=0, bool has_carriage_retu return 2; } + + +bool string_is_valid_identifier(String str) { + if (str.len <= 0) return false; + + isize rune_count = 0; + + isize w = 0; + isize offset = 0; + while (offset < str.len) { + Rune r = 0; + w = utf8_decode(str.text, str.len, &r); + if (r == GB_RUNE_INVALID) { + return false; + } + + if (rune_count == 0) { + if (!rune_is_letter(r)) { + return false; + } + } else { + if (!rune_is_letter(r) && !rune_is_digit(r)) { + return false; + } + } + rune_count += 1; + offset += w; + } + + return true; +} diff --git a/src/types.cpp b/src/types.cpp index 024d644a2..78958146b 100644 --- a/src/types.cpp +++ b/src/types.cpp @@ -393,6 +393,7 @@ struct Selection { bool indirect; // Set if there was a pointer deref anywhere down the line u8 swizzle_count; // maximum components = 4 u8 swizzle_indices; // 2 bits per component, representing which swizzle index + bool pseudo_field; }; Selection empty_selection = {0}; @@ -2782,6 +2783,7 @@ Selection lookup_field_from_index(Type *type, i64 index) { } Entity *scope_lookup_current(Scope *s, String const &name); +bool has_type_got_objc_class_attribute(Type *t); Selection lookup_field_with_selection(Type *type_, String field_name, bool is_type, Selection sel, bool allow_blank_ident) { GB_ASSERT(type_ != nullptr); @@ -2794,9 +2796,40 @@ Selection lookup_field_with_selection(Type *type_, String field_name, bool is_ty bool is_ptr = type != type_; sel.indirect = sel.indirect || is_ptr; + Type *original_type = type; + type = base_type(type); if (is_type) { + if (has_type_got_objc_class_attribute(original_type) && original_type->kind == Type_Named) { + Entity *e = original_type->Named.type_name; + GB_ASSERT(e->kind == Entity_TypeName); + if (e->TypeName.objc_metadata) { + auto *md = e->TypeName.objc_metadata; + mutex_lock(md->mutex); + defer (mutex_unlock(md->mutex)); + for (TypeNameObjCMetadataEntry const &entry : md->type_entries) { + GB_ASSERT(entry.entity->kind == Entity_Procedure); + if (entry.name == field_name) { + sel.entity = entry.entity; + sel.pseudo_field = true; + return sel; + } + } + } + if (type->kind == Type_Struct) { + for_array(i, type->Struct.fields) { + Entity *f = type->Struct.fields[i]; + if (f->flags&EntityFlag_Using) { + sel = lookup_field_with_selection(f->type, field_name, is_type, sel, allow_blank_ident); + if (sel.entity) { + return sel; + } + } + } + } + } + if (is_type_enum(type)) { // NOTE(bill): These may not have been added yet, so check in case for_array(i, type->Enum.fields) { @@ -2843,6 +2876,24 @@ Selection lookup_field_with_selection(Type *type_, String field_name, bool is_ty } else if (type->kind == Type_Union) { } else if (type->kind == Type_Struct) { + if (has_type_got_objc_class_attribute(original_type) && original_type->kind == Type_Named) { + Entity *e = original_type->Named.type_name; + GB_ASSERT(e->kind == Entity_TypeName); + if (e->TypeName.objc_metadata) { + auto *md = e->TypeName.objc_metadata; + mutex_lock(md->mutex); + defer (mutex_unlock(md->mutex)); + for (TypeNameObjCMetadataEntry const &entry : md->value_entries) { + GB_ASSERT(entry.entity->kind == Entity_Procedure); + if (entry.name == field_name) { + sel.entity = entry.entity; + sel.pseudo_field = true; + return sel; + } + } + } + } + for_array(i, type->Struct.fields) { Entity *f = type->Struct.fields[i]; if (f->kind != Entity_Variable || (f->flags & EntityFlag_Field) == 0) { @@ -3792,6 +3843,17 @@ bool is_type_subtype_of(Type *src, Type *dst) { } +bool has_type_got_objc_class_attribute(Type *t) { + return t->kind == Type_Named && t->Named.type_name != nullptr && t->Named.type_name->TypeName.objc_class_name != ""; +} + + + +bool is_type_objc_object(Type *t) { + bool internal_check_is_assignable_to(Type *src, Type *dst); + + return internal_check_is_assignable_to(t, t_objc_object); +} Type *get_struct_field_type(Type *t, isize index) { t = base_type(type_deref(t)); From acaae1357cf7d9a5b3cd94df123a8942c8290192 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Sat, 12 Feb 2022 17:30:32 +0000 Subject: [PATCH 14/64] Update Metal for the full API Methods need better names --- vendor/Metal/MTLAccelerationStructure.odin | 270 - .../Metal/MTLAccelerationStructureTypes.odin | 10 - vendor/Metal/MTLRenderPipeline.odin | 74 - .../Metal/MTLStageInputOutputDescriptor.odin | 76 - vendor/Metal/Metal.odin | 22 - vendor/Metal/MetalClasses.odin | 8076 +++++++++++++++++ vendor/Metal/MetalEnums.odin | 961 ++ vendor/Metal/MetalErrors.odin | 39 + vendor/Metal/MetalTypes.odin | 198 + vendor/Metal/NSBuffer.odin | 5 - vendor/Metal/NSResource.odin | 5 - 11 files changed, 9274 insertions(+), 462 deletions(-) delete mode 100644 vendor/Metal/MTLAccelerationStructure.odin delete mode 100644 vendor/Metal/MTLAccelerationStructureTypes.odin delete mode 100644 vendor/Metal/MTLRenderPipeline.odin delete mode 100644 vendor/Metal/MTLStageInputOutputDescriptor.odin delete mode 100644 vendor/Metal/Metal.odin create mode 100644 vendor/Metal/MetalClasses.odin create mode 100644 vendor/Metal/MetalEnums.odin create mode 100644 vendor/Metal/MetalErrors.odin create mode 100644 vendor/Metal/MetalTypes.odin delete mode 100644 vendor/Metal/NSBuffer.odin delete mode 100644 vendor/Metal/NSResource.odin diff --git a/vendor/Metal/MTLAccelerationStructure.odin b/vendor/Metal/MTLAccelerationStructure.odin deleted file mode 100644 index 342df3d07..000000000 --- a/vendor/Metal/MTLAccelerationStructure.odin +++ /dev/null @@ -1,270 +0,0 @@ -package objc_Metal - -import NS "core:sys/darwin/Foundation" - -AccelerationStructureUsage :: distinct bit_set[AccelerationStructureUsageFlag; NS.UInteger] -AccelerationStructureUsageFlag :: enum NS.UInteger { - Refit = 0, - PreferFastBuild = 1, - ExtendedLimits = 2, -} -AccelerationStructureUsageNone :: AccelerationStructureUsage{} - -AccelerationStructureInstanceOptions :: distinct bit_set[AccelerationStructureInstanceOption; u32] -AccelerationStructureInstanceOption :: enum u32 { - DisableTriangleCulling = 0, - TriangleFrontFacingWindingCounterClockwise = 1, - Opaque = 2, - NonOpaque = 3, -} -AccelerationStructureInstanceOptionNone :: AccelerationStructureInstanceOptions{} - -MotionBorderMode :: enum u32 { - Clamp = 0, - Vanish = 1, -} - -AccelerationStructureInstanceDescriptor :: struct #packed { - transformationMatrix: PackedFloat4x3, - options: AccelerationStructureInstanceOptions, - mask: u32, - intersectionFunctionTableOffset: u32, - accelerationStructureIndex: u32, -} - -AccelerationStructureUserIDInstanceDescriptor :: struct #packed { - transformationMatrix: PackedFloat4x3, - options: AccelerationStructureInstanceOptions, - mask: u32, - intersectionFunctionTableOffset: u32, - accelerationStructureIndex: u32, - userID: u32, -} - -AccelerationStructureInstanceDescriptorType :: enum NS.UInteger { - Default = 0, - UserID = 1, - Motion = 2, -} - -AccelerationStructureMotionInstanceDescriptor :: struct #packed { - options: AccelerationStructureInstanceOptions, - mask: u32, - intersectionFunctionTableOffset: u32, - accelerationStructureIndex: u32, - userID: u32, - motionTransformsStartIndex: u32, - motionTransformsCount: u32, - motionStartBorderMode: MotionBorderMode, - motionEndBorderMode: MotionBorderMode, - motionStartTime: f32, - motionEndTime: f32, -} - -@(objc_class="NSAccelerationStructureDescriptor") -AccelerationStructureDescriptor :: struct { using _: NS.Copying(AccelerationStructureDescriptor) } - -@(objc_class="NSAccelerationStructureGeometryDescriptor") -AccelerationStructureGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureGeometryDescriptor) } - -@(objc_class="NSPrimitiveAccelerationStructureDescriptor") -PrimitiveAccelerationStructureDescriptor :: struct { using _: NS.Copying(PrimitiveAccelerationStructureDescriptor), using _: AccelerationStructureDescriptor } - -@(objc_class="NSAccelerationStructureTriangleGeometryDescriptor") -AccelerationStructureTriangleGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureTriangleGeometryDescriptor), using _: AccelerationStructureGeometryDescriptor } - -@(objc_class="NSAccelerationStructureBoundingBoxGeometryDescriptor") -AccelerationStructureBoundingBoxGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureBoundingBoxGeometryDescriptor), using _: AccelerationStructureGeometryDescriptor } - -@(objc_class="NSMotionKeyframeData") -MotionKeyframeData :: struct { using _: NS.Object } - -@(objc_class="NSAccelerationStructureMotionTriangleGeometryDescriptor") -AccelerationStructureMotionTriangleGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureMotionTriangleGeometryDescriptor), using _: AccelerationStructureGeometryDescriptor } - -@(objc_class="NSAccelerationStructureMotionBoundingBoxGeometryDescriptor") -AccelerationStructureMotionBoundingBoxGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureMotionBoundingBoxGeometryDescriptor), using _: AccelerationStructureGeometryDescriptor } - -@(objc_class="NSInstanceAccelerationStructureDescriptor") -InstanceAccelerationStructureDescriptor :: struct { using _: NS.Copying(InstanceAccelerationStructureDescriptor), using _: AccelerationStructureGeometryDescriptor } - -@(objc_class="NSAccelerationStructure") -AccelerationStructure :: struct { using _: NS.Object } - - - -AccelerationStructureDescriptor_usage :: proc(self: ^AccelerationStructureDescriptor) -> AccelerationStructureUsage { - return msgSend(AccelerationStructureUsage, self, "usage") -} - -AccelerationStructureGeometryDescriptor_intersectionFunctionTableOffset :: proc(self: ^AccelerationStructureGeometryDescriptor) -> NS.UInteger { - return msgSend(NS.UInteger, self, "intersectionFunctionTableOffset") -} - -AccelerationStructureGeometryDescriptor_setIntersectionFunctionTableOffset :: proc(self: ^AccelerationStructureGeometryDescriptor, intersectionFunctionTableOffset: NS.UInteger) { - msgSend(nil, self, "setIntersectionFunctionTableOffset:", intersectionFunctionTableOffset) -} - -AccelerationStructureGeometryDescriptor_opaque :: proc(self: ^AccelerationStructureGeometryDescriptor) -> BOOL { - return msgSend(BOOL, self, "opaque") -} - -AccelerationStructureGeometryDescriptor_setOpaque :: proc(self: ^AccelerationStructureGeometryDescriptor, opaque: BOOL) { - msgSend(nil, self, "setOpaque:", opaque) -} - -AccelerationStructureGeometryDescriptor_allowDuplicateIntersectionFunctionInvocation :: proc(self: ^AccelerationStructureGeometryDescriptor) -> BOOL { - return msgSend(BOOL, self, "allowDuplicateIntersectionFunctionInvocation") -} - -AccelerationStructureGeometryDescriptor_setAllowDuplicateIntersectionFunctionInvocation :: proc(self: ^AccelerationStructureGeometryDescriptor, allowDuplicateIntersectionFunctionInvocation: BOOL) { - msgSend(nil, self, "setAllowDuplicateIntersectionFunctionInvocation:", allowDuplicateIntersectionFunctionInvocation) -} - - -AccelerationStructureGeometryDescriptor_label :: proc(self: ^AccelerationStructureGeometryDescriptor) -> ^NS.String { - return msgSend(^NS.String, self, "label") -} - -AccelerationStructureGeometryDescriptor_setLabel :: proc(self: ^AccelerationStructureGeometryDescriptor, label: ^NS.String) { - msgSend(nil, self, "setLabel:", label) -} - -PrimitiveAccelerationStructureDescriptor_geometryDescriptors :: proc(self: ^PrimitiveAccelerationStructureDescriptor) -> (descriptors: ^NS.Array(^NS.Object)) { - return msgSend(type_of(descriptors), self, "geometryDescriptors") -} - -PrimitiveAccelerationStructureDescriptor_setGeometryDescriptors :: proc(self: ^PrimitiveAccelerationStructureDescriptor, descriptors: ^NS.Array(^NS.Object)) { - msgSend(nil, self, "setGeometryDescriptors:", descriptors) -} - -PrimitiveAccelerationStructureDescriptor_motionStartBorderMode :: proc(self: ^PrimitiveAccelerationStructureDescriptor) -> MotionBorderMode { - return msgSend(MotionBorderMode, self, "motionStartBorderMode") -} -PrimitiveAccelerationStructureDescriptor_setMotionStartBorderMode :: proc(self: ^PrimitiveAccelerationStructureDescriptor, motionStartBorderMode: MotionBorderMode) { - msgSend(nil, self, "setMotionStartBorderMode:", motionStartBorderMode) -} - -PrimitiveAccelerationStructureDescriptor_motionEndBorderMode :: proc(self: ^PrimitiveAccelerationStructureDescriptor) -> MotionBorderMode { - return msgSend(MotionBorderMode, self, "motionEndBorderMode") -} -PrimitiveAccelerationStructureDescriptor_setMotionEndBorderMode :: proc(self: ^PrimitiveAccelerationStructureDescriptor, motionEndBorderMode: MotionBorderMode) { - msgSend(nil, self, "setMotionEndBorderMode:", motionEndBorderMode) -} - -PrimitiveAccelerationStructureDescriptor_motionStartTime :: proc(self: ^PrimitiveAccelerationStructureDescriptor) -> (motionStartTime: f32) { - return msgSend(f32, self, "motionStartTime") -} -PrimitiveAccelerationStructureDescriptor_setMotionStartTime :: proc(self: ^PrimitiveAccelerationStructureDescriptor, motionStartTime: f32) { - msgSend(nil, self, "setMotionStartTime:", motionStartTime) -} - - -PrimitiveAccelerationStructureDescriptor_motionEndTime :: proc(self: ^PrimitiveAccelerationStructureDescriptor) -> (motionEndTime: f32) { - return msgSend(f32, self, "motionEndTime") -} -PrimitiveAccelerationStructureDescriptor_setMotionEndTime :: proc(self: ^PrimitiveAccelerationStructureDescriptor, motionEndTime: f32) { - msgSend(nil, self, "setMotionEndTime:", motionEndTime) -} - - -PrimitiveAccelerationStructureDescriptor_motionKeyframeCount :: proc(self: ^PrimitiveAccelerationStructureDescriptor) -> (motionKeyframeCount: NS.UInteger) { - return msgSend(NS.UInteger, self, "motionKeyframeCount") -} -PrimitiveAccelerationStructureDescriptor_setmotionKeyframeCount :: proc(self: ^PrimitiveAccelerationStructureDescriptor, motionKeyframeCount: NS.UInteger) { - msgSend(nil, self, "setMotionKeyframeCount:", motionKeyframeCount) -} - -PrimitiveAccelerationStructureDescriptor_descriptor :: proc() -> ^PrimitiveAccelerationStructureDescriptor { - return msgSend(^PrimitiveAccelerationStructureDescriptor, PrimitiveAccelerationStructureDescriptor, "descriptor") -} - - -AccelerationStructureTriangleGeometryDescriptor_vertexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^Buffer { - return msgSend(^Buffer, self, "vertexBuffer") -} -AccelerationStructureTriangleGeometryDescriptor_setVertexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, buffer: ^Buffer) { - msgSend(nil, self, "setVertexBuffer:", buffer) -} - -AccelerationStructureTriangleGeometryDescriptor_vertexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { - return msgSend(NS.UInteger, self, "vertexBufferOffset") -} -AccelerationStructureTriangleGeometryDescriptor_setVertexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexBufferOffset: NS.UInteger) { - msgSend(nil, self, "setVertexBufferOffset:", vertexBufferOffset) -} - -AccelerationStructureTriangleGeometryDescriptor_vertexStride :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { - return msgSend(NS.UInteger, self, "vertexStride") -} -AccelerationStructureTriangleGeometryDescriptor_setVertexStride :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexStride: NS.UInteger) { - msgSend(nil, self, "setVertexStride:", vertexStride) -} - -AccelerationStructureTriangleGeometryDescriptor_indexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^Buffer { - return msgSend(^Buffer, self, "indexBuffer") -} -AccelerationStructureTriangleGeometryDescriptor_setIndexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, buffer: ^Buffer) { - msgSend(nil, self, "setIndexBuffer:", buffer) -} - -AccelerationStructureTriangleGeometryDescriptor_indexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { - return msgSend(NS.UInteger, self, "indexBufferOffset") -} -AccelerationStructureTriangleGeometryDescriptor_setIndexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexBufferOffset: NS.UInteger) { - msgSend(nil, self, "setIndexBufferOffset:", indexBufferOffset) -} - - - -AccelerationStructureTriangleGeometryDescriptor_indexType :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> IndexType { - return msgSend(IndexType, self, "indexType") -} -AccelerationStructureTriangleGeometryDescriptor_setIndexType :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indextype: IndexType) { - msgSend(nil, self, "setIndexType:", indextype) -} - -AccelerationStructureTriangleGeometryDescriptor_triangleCount :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { - return msgSend(NS.UInteger, self, "triangleCount") -} -AccelerationStructureTriangleGeometryDescriptor_setTriangleCount :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, triangleCount: NS.UInteger) { - msgSend(nil, self, "setTriangleCount", triangleCount) -} - - -AccelerationStructureTriangleGeometryDescriptor_descriptor :: proc() -> ^AccelerationStructureTriangleGeometryDescriptor { - return msgSend(^AccelerationStructureTriangleGeometryDescriptor, AccelerationStructureTriangleGeometryDescriptor, "descriptor") -} - -AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBuffer :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> ^Buffer { - return msgSend(^Buffer, self, "boundingBoxBuffer") -} - -AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBuffer :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, buffer: ^Buffer) { - msgSend(nil, self, "setBoundingBoxBuffer:", buffer) -} - -AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBufferOffset :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.UInteger { - return msgSend(NS.UInteger, self, "boundingBoxBufferOffset") -} - -AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBufferOffset :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBufferOffset: NS.UInteger) { - msgSend(nil, self, "setBoundingBoxBufferOffset:", boundingBoxBufferOffset) -} - - -AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxStride :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.UInteger { - return msgSend(NS.UInteger, self, "boundingBoxStride") -} - -AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxStride :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxStride: NS.UInteger) { - msgSend(nil, self, "setBoundingBoxStride:", boundingBoxStride) -} - -AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxCount :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.UInteger { - return msgSend(NS.UInteger, self, "boundingBoxCount") -} - -AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxCount :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxCount: NS.UInteger) { - msgSend(nil, self, "setBoundingBoxCount:", boundingBoxCount) -} diff --git a/vendor/Metal/MTLAccelerationStructureTypes.odin b/vendor/Metal/MTLAccelerationStructureTypes.odin deleted file mode 100644 index eba672836..000000000 --- a/vendor/Metal/MTLAccelerationStructureTypes.odin +++ /dev/null @@ -1,10 +0,0 @@ -package objc_Metal - -import NS "core:sys/darwin/Foundation" - -PackedFloat3 :: distinct [3]f32 -PackedFloat4x3 :: distinct [4]PackedFloat3 - -AxisAlignedBoundingBox :: struct{ - min, ax: PackedFloat3, -} \ No newline at end of file diff --git a/vendor/Metal/MTLRenderPipeline.odin b/vendor/Metal/MTLRenderPipeline.odin deleted file mode 100644 index c05c02c64..000000000 --- a/vendor/Metal/MTLRenderPipeline.odin +++ /dev/null @@ -1,74 +0,0 @@ -package objc_Metal - -import NS "core:sys/darwin/Foundation" - -BlendFactor :: enum NS.UInteger { - Zero = 0, - One = 1, - SourceColor = 2, - OneMinusSourceColor = 3, - SourceAlpha = 4, - OneMinusSourceAlpha = 5, - DestinationColor = 6, - OneMinusDestinationColor = 7, - DestinationAlpha = 8, - OneMinusDestinationAlpha = 9, - SourceAlphaSaturated = 10, - BlendColor = 11, - OneMinusBlendColor = 12, - BlendAlpha = 13, - OneMinusBlendAlpha = 14, - Source1Color = 15, - OneMinusSource1Color = 16, - Source1Alpha = 17, - OneMinusSource1Alpha = 18, -} - -BlendOperation :: enum NS.UInteger { - Add = 0, - Subtract = 1, - ReverseSubtract = 2, - Min = 3, - Max = 4, -} - -ColorWriteMaskOption :: enum NS.UInteger { - Alpha = 0, - Blue = 1, - Green = 2, - Red = 3, -} -ColorWriteMask :: distinct bit_set[ColorWriteMaskOption; NS.UInteger] -ColorWriteMaskNone :: ColorWriteMask{} -ColorWriteMaskAll :: ColorWriteMask{.Alpha, .Blue, .Green, .Red} - -PrimitiveTopologyClass :: enum NS.UInteger { - ClassUnspecified = 0, - ClassPoint = 1, - ClassLine = 2, - ClassTriangle = 3, -} - -TessellationPartitionMode :: enum NS.UInteger { - ModePow2 = 0, - ModeInteger = 1, - ModeFractionalOdd = 2, - ModeFractionalEven = 3, -} - -TessellationFactorStepFunction :: enum NS.UInteger { - Constant = 0, - PerPatch = 1, - PerInstance = 2, - PerPatchAndPerInstance = 3, -} - -TessellationFactorFormat :: enum NS.UInteger { - Half = 0, -} - -TessellationControlPointIndexType :: enum NS.UInteger { - None = 0, - UInt16 = 1, - UInt32 = 2, -} diff --git a/vendor/Metal/MTLStageInputOutputDescriptor.odin b/vendor/Metal/MTLStageInputOutputDescriptor.odin deleted file mode 100644 index 98ff66ce5..000000000 --- a/vendor/Metal/MTLStageInputOutputDescriptor.odin +++ /dev/null @@ -1,76 +0,0 @@ -package objc_Metal - -import NS "core:sys/darwin/Foundation" - - -AttributeFormat :: enum NS.UInteger { - Invalid = 0, - UChar2 = 1, - UChar3 = 2, - UChar4 = 3, - Char2 = 4, - Char3 = 5, - Char4 = 6, - UChar2Normalized = 7, - UChar3Normalized = 8, - UChar4Normalized = 9, - Char2Normalized = 10, - Char3Normalized = 11, - Char4Normalized = 12, - UShort2 = 13, - UShort3 = 14, - UShort4 = 15, - Short2 = 16, - Short3 = 17, - Short4 = 18, - UShort2Normalized = 19, - UShort3Normalized = 20, - UShort4Normalized = 21, - Short2Normalized = 22, - Short3Normalized = 23, - Short4Normalized = 24, - Half2 = 25, - Half3 = 26, - Half4 = 27, - Float = 28, - Float2 = 29, - Float3 = 30, - Float4 = 31, - Int = 32, - Int2 = 33, - Int3 = 34, - Int4 = 35, - UInt = 36, - UInt2 = 37, - UInt3 = 38, - UInt4 = 39, - Int1010102Normalized = 40, - UInt1010102Normalized = 41, - UChar4Normalized_BGRA = 42, - UChar = 45, - Char = 46, - UCharNormalized = 47, - CharNormalized = 48, - UShort = 49, - Short = 50, - UShortNormalized = 51, - ShortNormalized = 52, - Half = 53, -} - -IndexType :: enum NS.UInteger { - UInt16 = 0, - UInt32 = 1, -} - -StepFunction :: enum NS.UInteger { - Constant = 0, - PerVertex = 1, - PerInstance = 2, - PerPatch = 3, - PerPatchControlPoint = 4, - ThreadPositionInGridX = 5, - ThreadPositionInGridY = 6, - ThreadPositionInGridXIndexed = 7, - ThreadPositionInGridYIndexed = 8, -} \ No newline at end of file diff --git a/vendor/Metal/Metal.odin b/vendor/Metal/Metal.odin deleted file mode 100644 index eefada00d..000000000 --- a/vendor/Metal/Metal.odin +++ /dev/null @@ -1,22 +0,0 @@ -package objc_Metal - -import NS "core:sys/darwin/Foundation" -import "core:intrinsics" - -alloc :: NS.alloc -init :: NS.init -retain :: NS.retain -release :: NS.release -autorelease :: NS.autorelease -retainCount :: NS.retainCount -copy :: NS.copy -hash :: NS.hash -isEqual :: NS.isEqual -description :: NS.description -debugDescription :: NS.debugDescription -bridgingCast :: NS.bridgingCast - -@(private) -msgSend :: intrinsics.objc_send - -BOOL :: NS.BOOL \ No newline at end of file diff --git a/vendor/Metal/MetalClasses.odin b/vendor/Metal/MetalClasses.odin new file mode 100644 index 000000000..138677d0d --- /dev/null +++ b/vendor/Metal/MetalClasses.odin @@ -0,0 +1,8076 @@ +package objc_Metal + +import NS "core:sys/darwin/Foundation" + +foreign import "system:Metal.framework" + +@(default_calling_convention="c", link_prefix="MTL") +foreign Metal { + CopyAllDevices :: proc() -> ^NS.Array --- + CopyAllDevicesWithObserver :: proc(observer: ^^NS.Object, handler: DeviceNotificationHandler) -> ^NS.Array --- + CreateSystemDefaultDevice :: proc() -> ^NS.Object --- + RemoveDeviceObserver :: proc(observer: ^NS.Object) --- +} + + + + + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + AccelerationStructureBoundingBoxGeometryDescriptor +Class Methods: + alloc + descriptor +Methods: + init + boundingBoxBuffer + boundingBoxBufferOffset + boundingBoxCount + boundingBoxStride + setBoundingBoxBuffer + setBoundingBoxBufferOffset + setBoundingBoxCount + setBoundingBoxStride +*/ +@(objc_class="MTLAccelerationStructureBoundingBoxGeometryDescriptor") +AccelerationStructureBoundingBoxGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureBoundingBoxGeometryDescriptor) } + +@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_class_name="alloc") +AccelerationStructureBoundingBoxGeometryDescriptor_alloc :: proc() -> ^AccelerationStructureBoundingBoxGeometryDescriptor { + return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, AccelerationStructureBoundingBoxGeometryDescriptor, "alloc") +} +@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="init") +AccelerationStructureBoundingBoxGeometryDescriptor_init :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> ^AccelerationStructureBoundingBoxGeometryDescriptor { + return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, self, "init") +} +@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxBuffer") +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBuffer :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> ^AccelerationStructureBoundingBoxGeometryDescriptor { + return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, self, "boundingBoxBuffer") +} +@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxBufferOffset") +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBufferOffset :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "boundingBoxBufferOffset") +} +@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxCount") +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxCount :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "boundingBoxCount") +} +@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxStride") +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxStride :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "boundingBoxStride") +} +@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_class_name="descriptor") +AccelerationStructureBoundingBoxGeometryDescriptor_descriptor :: proc() -> ^AccelerationStructureBoundingBoxGeometryDescriptor { + return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, AccelerationStructureBoundingBoxGeometryDescriptor, "descriptor") +} +@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxBuffer") +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBuffer :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBuffer: ^NS.Object) { + msgSend(nil, self, "setBoundingBoxBuffer:", boundingBoxBuffer) +} +@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxBufferOffset") +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBufferOffset :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBufferOffset: NS.Integer) { + msgSend(nil, self, "setBoundingBoxBufferOffset:", boundingBoxBufferOffset) +} +@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxCount") +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxCount :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxCount: NS.Integer) { + msgSend(nil, self, "setBoundingBoxCount:", boundingBoxCount) +} +@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxStride") +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxStride :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxStride: NS.Integer) { + msgSend(nil, self, "setBoundingBoxStride:", boundingBoxStride) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + AccelerationStructureDescriptor +Class Methods: + alloc +Methods: + init + setUsage + usage +*/ +@(objc_class="MTLAccelerationStructureDescriptor") +AccelerationStructureDescriptor :: struct { using _: NS.Copying(AccelerationStructureDescriptor) } + +@(objc_type=AccelerationStructureDescriptor, objc_class_name="alloc") +AccelerationStructureDescriptor_alloc :: proc() -> ^AccelerationStructureDescriptor { + return msgSend(^AccelerationStructureDescriptor, AccelerationStructureDescriptor, "alloc") +} +@(objc_type=AccelerationStructureDescriptor, objc_name="init") +AccelerationStructureDescriptor_init :: proc(self: ^AccelerationStructureDescriptor) -> ^AccelerationStructureDescriptor { + return msgSend(^AccelerationStructureDescriptor, self, "init") +} +@(objc_type=AccelerationStructureDescriptor, objc_name="setUsage") +AccelerationStructureDescriptor_setUsage :: proc(self: ^AccelerationStructureDescriptor, usage: AccelerationStructureUsage) { + msgSend(nil, self, "setUsage:", usage) +} +@(objc_type=AccelerationStructureDescriptor, objc_name="usage") +AccelerationStructureDescriptor_usage :: proc(self: ^AccelerationStructureDescriptor) -> AccelerationStructureUsage { + return msgSend(AccelerationStructureUsage, self, "usage") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + AccelerationStructureGeometryDescriptor +Class Methods: + alloc +Methods: + init + allowDuplicateIntersectionFunctionInvocation + intersectionFunctionTableOffset + opaque + setAllowDuplicateIntersectionFunctionInvocation + setIntersectionFunctionTableOffset + setOpaque +*/ +@(objc_class="MTLAccelerationStructureGeometryDescriptor") +AccelerationStructureGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureGeometryDescriptor) } + +@(objc_type=AccelerationStructureGeometryDescriptor, objc_class_name="alloc") +AccelerationStructureGeometryDescriptor_alloc :: proc() -> ^AccelerationStructureGeometryDescriptor { + return msgSend(^AccelerationStructureGeometryDescriptor, AccelerationStructureGeometryDescriptor, "alloc") +} +@(objc_type=AccelerationStructureGeometryDescriptor, objc_name="init") +AccelerationStructureGeometryDescriptor_init :: proc(self: ^AccelerationStructureGeometryDescriptor) -> ^AccelerationStructureGeometryDescriptor { + return msgSend(^AccelerationStructureGeometryDescriptor, self, "init") +} +@(objc_type=AccelerationStructureGeometryDescriptor, objc_name="allowDuplicateIntersectionFunctionInvocation") +AccelerationStructureGeometryDescriptor_allowDuplicateIntersectionFunctionInvocation :: proc(self: ^AccelerationStructureGeometryDescriptor) -> BOOL { + return msgSend(BOOL, self, "allowDuplicateIntersectionFunctionInvocation") +} +@(objc_type=AccelerationStructureGeometryDescriptor, objc_name="intersectionFunctionTableOffset") +AccelerationStructureGeometryDescriptor_intersectionFunctionTableOffset :: proc(self: ^AccelerationStructureGeometryDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "intersectionFunctionTableOffset") +} +@(objc_type=AccelerationStructureGeometryDescriptor, objc_name="opaque") +AccelerationStructureGeometryDescriptor_opaque :: proc(self: ^AccelerationStructureGeometryDescriptor) -> BOOL { + return msgSend(BOOL, self, "opaque") +} +@(objc_type=AccelerationStructureGeometryDescriptor, objc_name="setAllowDuplicateIntersectionFunctionInvocation") +AccelerationStructureGeometryDescriptor_setAllowDuplicateIntersectionFunctionInvocation :: proc(self: ^AccelerationStructureGeometryDescriptor, allowDuplicateIntersectionFunctionInvocation: BOOL) { + msgSend(nil, self, "setAllowDuplicateIntersectionFunctionInvocation:", allowDuplicateIntersectionFunctionInvocation) +} +@(objc_type=AccelerationStructureGeometryDescriptor, objc_name="setIntersectionFunctionTableOffset") +AccelerationStructureGeometryDescriptor_setIntersectionFunctionTableOffset :: proc(self: ^AccelerationStructureGeometryDescriptor, intersectionFunctionTableOffset: NS.Integer) { + msgSend(nil, self, "setIntersectionFunctionTableOffset:", intersectionFunctionTableOffset) +} +@(objc_type=AccelerationStructureGeometryDescriptor, objc_name="setOpaque") +AccelerationStructureGeometryDescriptor_setOpaque :: proc(self: ^AccelerationStructureGeometryDescriptor, opaque: BOOL) { + msgSend(nil, self, "setOpaque:", opaque) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + AccelerationStructureTriangleGeometryDescriptor +Class Methods: + alloc + descriptor +Methods: + init + indexBuffer + indexBufferOffset + indexType + setIndexBuffer + setIndexBufferOffset + setIndexType + setTriangleCount + setVertexBuffer + setVertexBufferOffset + setVertexStride + triangleCount + vertexBuffer + vertexBufferOffset + vertexStride +*/ +@(objc_class="MTLAccelerationStructureTriangleGeometryDescriptor") +AccelerationStructureTriangleGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureTriangleGeometryDescriptor) } + +@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_class_name="alloc") +AccelerationStructureTriangleGeometryDescriptor_alloc :: proc() -> ^AccelerationStructureTriangleGeometryDescriptor { + return msgSend(^AccelerationStructureTriangleGeometryDescriptor, AccelerationStructureTriangleGeometryDescriptor, "alloc") +} +@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="init") +AccelerationStructureTriangleGeometryDescriptor_init :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^AccelerationStructureTriangleGeometryDescriptor { + return msgSend(^AccelerationStructureTriangleGeometryDescriptor, self, "init") +} +@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_class_name="descriptor") +AccelerationStructureTriangleGeometryDescriptor_descriptor :: proc() -> ^AccelerationStructureTriangleGeometryDescriptor { + return msgSend(^AccelerationStructureTriangleGeometryDescriptor, AccelerationStructureTriangleGeometryDescriptor, "descriptor") +} +@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="indexBuffer") +AccelerationStructureTriangleGeometryDescriptor_indexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^AccelerationStructureTriangleGeometryDescriptor { + return msgSend(^AccelerationStructureTriangleGeometryDescriptor, self, "indexBuffer") +} +@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="indexBufferOffset") +AccelerationStructureTriangleGeometryDescriptor_indexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "indexBufferOffset") +} +@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="indexType") +AccelerationStructureTriangleGeometryDescriptor_indexType :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> IndexType { + return msgSend(IndexType, self, "indexType") +} +@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setIndexBuffer") +AccelerationStructureTriangleGeometryDescriptor_setIndexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexBuffer: ^NS.Object) { + msgSend(nil, self, "setIndexBuffer:", indexBuffer) +} +@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setIndexBufferOffset") +AccelerationStructureTriangleGeometryDescriptor_setIndexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexBufferOffset: NS.Integer) { + msgSend(nil, self, "setIndexBufferOffset:", indexBufferOffset) +} +@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setIndexType") +AccelerationStructureTriangleGeometryDescriptor_setIndexType :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexType: IndexType) { + msgSend(nil, self, "setIndexType:", indexType) +} +@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setTriangleCount") +AccelerationStructureTriangleGeometryDescriptor_setTriangleCount :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, triangleCount: NS.Integer) { + msgSend(nil, self, "setTriangleCount:", triangleCount) +} +@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setVertexBuffer") +AccelerationStructureTriangleGeometryDescriptor_setVertexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexBuffer: ^NS.Object) { + msgSend(nil, self, "setVertexBuffer:", vertexBuffer) +} +@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setVertexBufferOffset") +AccelerationStructureTriangleGeometryDescriptor_setVertexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexBufferOffset: NS.Integer) { + msgSend(nil, self, "setVertexBufferOffset:", vertexBufferOffset) +} +@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setVertexStride") +AccelerationStructureTriangleGeometryDescriptor_setVertexStride :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexStride: NS.Integer) { + msgSend(nil, self, "setVertexStride:", vertexStride) +} +@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="triangleCount") +AccelerationStructureTriangleGeometryDescriptor_triangleCount :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "triangleCount") +} +@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="vertexBuffer") +AccelerationStructureTriangleGeometryDescriptor_vertexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^AccelerationStructureTriangleGeometryDescriptor { + return msgSend(^AccelerationStructureTriangleGeometryDescriptor, self, "vertexBuffer") +} +@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="vertexBufferOffset") +AccelerationStructureTriangleGeometryDescriptor_vertexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "vertexBufferOffset") +} +@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="vertexStride") +AccelerationStructureTriangleGeometryDescriptor_vertexStride :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "vertexStride") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + Argument +Class Methods: + alloc +Methods: + init + access + arrayLength + bufferAlignment + bufferDataSize + bufferDataType + bufferPointerType + bufferStructType + index + isActive + isDepthTexture + name + textureDataType + textureType + threadgroupMemoryAlignment + threadgroupMemoryDataSize + type +*/ +@(objc_class="MTLArgument") +Argument :: struct { using _: NS.Object } + +@(objc_type=Argument, objc_class_name="alloc") +Argument_alloc :: proc() -> ^Argument { + return msgSend(^Argument, Argument, "alloc") +} +@(objc_type=Argument, objc_name="init") +Argument_init :: proc(self: ^Argument) -> ^Argument { + return msgSend(^Argument, self, "init") +} +@(objc_type=Argument, objc_name="access") +Argument_access :: proc(self: ^Argument) -> ArgumentAccess { + return msgSend(ArgumentAccess, self, "access") +} +@(objc_type=Argument, objc_name="arrayLength") +Argument_arrayLength :: proc(self: ^Argument) -> NS.Integer { + return msgSend(NS.Integer, self, "arrayLength") +} +@(objc_type=Argument, objc_name="bufferAlignment") +Argument_bufferAlignment :: proc(self: ^Argument) -> NS.Integer { + return msgSend(NS.Integer, self, "bufferAlignment") +} +@(objc_type=Argument, objc_name="bufferDataSize") +Argument_bufferDataSize :: proc(self: ^Argument) -> NS.Integer { + return msgSend(NS.Integer, self, "bufferDataSize") +} +@(objc_type=Argument, objc_name="bufferDataType") +Argument_bufferDataType :: proc(self: ^Argument) -> DataType { + return msgSend(DataType, self, "bufferDataType") +} +@(objc_type=Argument, objc_name="bufferPointerType") +Argument_bufferPointerType :: proc(self: ^Argument) -> ^PointerType { + return msgSend(^PointerType, self, "bufferPointerType") +} +@(objc_type=Argument, objc_name="bufferStructType") +Argument_bufferStructType :: proc(self: ^Argument) -> ^StructType { + return msgSend(^StructType, self, "bufferStructType") +} +@(objc_type=Argument, objc_name="index") +Argument_index :: proc(self: ^Argument) -> NS.Integer { + return msgSend(NS.Integer, self, "index") +} +@(objc_type=Argument, objc_name="isActive") +Argument_isActive :: proc(self: ^Argument) -> BOOL { + return msgSend(BOOL, self, "isActive") +} +@(objc_type=Argument, objc_name="isDepthTexture") +Argument_isDepthTexture :: proc(self: ^Argument) -> BOOL { + return msgSend(BOOL, self, "isDepthTexture") +} +@(objc_type=Argument, objc_name="name") +Argument_name :: proc(self: ^Argument) -> ^NS.String { + return msgSend(^NS.String, self, "name") +} +@(objc_type=Argument, objc_name="textureDataType") +Argument_textureDataType :: proc(self: ^Argument) -> DataType { + return msgSend(DataType, self, "textureDataType") +} +@(objc_type=Argument, objc_name="textureType") +Argument_textureType :: proc(self: ^Argument) -> TextureType { + return msgSend(TextureType, self, "textureType") +} +@(objc_type=Argument, objc_name="threadgroupMemoryAlignment") +Argument_threadgroupMemoryAlignment :: proc(self: ^Argument) -> NS.Integer { + return msgSend(NS.Integer, self, "threadgroupMemoryAlignment") +} +@(objc_type=Argument, objc_name="threadgroupMemoryDataSize") +Argument_threadgroupMemoryDataSize :: proc(self: ^Argument) -> NS.Integer { + return msgSend(NS.Integer, self, "threadgroupMemoryDataSize") +} +@(objc_type=Argument, objc_name="type") +Argument_type :: proc(self: ^Argument) -> ArgumentType { + return msgSend(ArgumentType, self, "type") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + ArgumentDescriptor +Class Methods: + alloc + argumentDescriptor +Methods: + init + access + arrayLength + constantBlockAlignment + dataType + index + setAccess + setArrayLength + setConstantBlockAlignment + setDataType + setIndex + setTextureType + textureType +*/ +@(objc_class="MTLArgumentDescriptor") +ArgumentDescriptor :: struct { using _: NS.Copying(ArgumentDescriptor) } + +@(objc_type=ArgumentDescriptor, objc_class_name="alloc") +ArgumentDescriptor_alloc :: proc() -> ^ArgumentDescriptor { + return msgSend(^ArgumentDescriptor, ArgumentDescriptor, "alloc") +} +@(objc_type=ArgumentDescriptor, objc_name="init") +ArgumentDescriptor_init :: proc(self: ^ArgumentDescriptor) -> ^ArgumentDescriptor { + return msgSend(^ArgumentDescriptor, self, "init") +} +@(objc_type=ArgumentDescriptor, objc_name="access") +ArgumentDescriptor_access :: proc(self: ^ArgumentDescriptor) -> ArgumentAccess { + return msgSend(ArgumentAccess, self, "access") +} +@(objc_type=ArgumentDescriptor, objc_class_name="argumentDescriptor") +ArgumentDescriptor_argumentDescriptor :: proc() -> ^ArgumentDescriptor { + return msgSend(^ArgumentDescriptor, ArgumentDescriptor, "argumentDescriptor") +} +@(objc_type=ArgumentDescriptor, objc_name="arrayLength") +ArgumentDescriptor_arrayLength :: proc(self: ^ArgumentDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "arrayLength") +} +@(objc_type=ArgumentDescriptor, objc_name="constantBlockAlignment") +ArgumentDescriptor_constantBlockAlignment :: proc(self: ^ArgumentDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "constantBlockAlignment") +} +@(objc_type=ArgumentDescriptor, objc_name="dataType") +ArgumentDescriptor_dataType :: proc(self: ^ArgumentDescriptor) -> DataType { + return msgSend(DataType, self, "dataType") +} +@(objc_type=ArgumentDescriptor, objc_name="index") +ArgumentDescriptor_index :: proc(self: ^ArgumentDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "index") +} +@(objc_type=ArgumentDescriptor, objc_name="setAccess") +ArgumentDescriptor_setAccess :: proc(self: ^ArgumentDescriptor, access: ArgumentAccess) { + msgSend(nil, self, "setAccess:", access) +} +@(objc_type=ArgumentDescriptor, objc_name="setArrayLength") +ArgumentDescriptor_setArrayLength :: proc(self: ^ArgumentDescriptor, arrayLength: NS.Integer) { + msgSend(nil, self, "setArrayLength:", arrayLength) +} +@(objc_type=ArgumentDescriptor, objc_name="setConstantBlockAlignment") +ArgumentDescriptor_setConstantBlockAlignment :: proc(self: ^ArgumentDescriptor, constantBlockAlignment: NS.Integer) { + msgSend(nil, self, "setConstantBlockAlignment:", constantBlockAlignment) +} +@(objc_type=ArgumentDescriptor, objc_name="setDataType") +ArgumentDescriptor_setDataType :: proc(self: ^ArgumentDescriptor, dataType: DataType) { + msgSend(nil, self, "setDataType:", dataType) +} +@(objc_type=ArgumentDescriptor, objc_name="setIndex") +ArgumentDescriptor_setIndex :: proc(self: ^ArgumentDescriptor, index: NS.Integer) { + msgSend(nil, self, "setIndex:", index) +} +@(objc_type=ArgumentDescriptor, objc_name="setTextureType") +ArgumentDescriptor_setTextureType :: proc(self: ^ArgumentDescriptor, textureType: TextureType) { + msgSend(nil, self, "setTextureType:", textureType) +} +@(objc_type=ArgumentDescriptor, objc_name="textureType") +ArgumentDescriptor_textureType :: proc(self: ^ArgumentDescriptor) -> TextureType { + return msgSend(TextureType, self, "textureType") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + ArrayType +Class Methods: + alloc +Methods: + init + argumentIndexStride + arrayLength + elementArrayType + elementPointerType + elementStructType + elementTextureReferenceType + elementType + stride +*/ +@(objc_class="MTLArrayType") +ArrayType :: struct { using _: NS.Object } + +@(objc_type=ArrayType, objc_class_name="alloc") +ArrayType_alloc :: proc() -> ^ArrayType { + return msgSend(^ArrayType, ArrayType, "alloc") +} +@(objc_type=ArrayType, objc_name="init") +ArrayType_init :: proc(self: ^ArrayType) -> ^ArrayType { + return msgSend(^ArrayType, self, "init") +} +@(objc_type=ArrayType, objc_name="argumentIndexStride") +ArrayType_argumentIndexStride :: proc(self: ^ArrayType) -> NS.Integer { + return msgSend(NS.Integer, self, "argumentIndexStride") +} +@(objc_type=ArrayType, objc_name="arrayLength") +ArrayType_arrayLength :: proc(self: ^ArrayType) -> NS.Integer { + return msgSend(NS.Integer, self, "arrayLength") +} +@(objc_type=ArrayType, objc_name="elementArrayType") +ArrayType_elementArrayType :: proc(self: ^ArrayType) -> ^ArrayType { + return msgSend(^ArrayType, self, "elementArrayType") +} +@(objc_type=ArrayType, objc_name="elementPointerType") +ArrayType_elementPointerType :: proc(self: ^ArrayType) -> ^PointerType { + return msgSend(^PointerType, self, "elementPointerType") +} +@(objc_type=ArrayType, objc_name="elementStructType") +ArrayType_elementStructType :: proc(self: ^ArrayType) -> ^StructType { + return msgSend(^StructType, self, "elementStructType") +} +@(objc_type=ArrayType, objc_name="elementTextureReferenceType") +ArrayType_elementTextureReferenceType :: proc(self: ^ArrayType) -> ^TextureReferenceType { + return msgSend(^TextureReferenceType, self, "elementTextureReferenceType") +} +@(objc_type=ArrayType, objc_name="elementType") +ArrayType_elementType :: proc(self: ^ArrayType) -> DataType { + return msgSend(DataType, self, "elementType") +} +@(objc_type=ArrayType, objc_name="stride") +ArrayType_stride :: proc(self: ^ArrayType) -> NS.Integer { + return msgSend(NS.Integer, self, "stride") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + Attribute +Class Methods: + alloc +Methods: + init + attributeIndex + attributeType + isActive + isPatchControlPointData + isPatchData + name +*/ +@(objc_class="MTLAttribute") +Attribute :: struct { using _: NS.Object } + +@(objc_type=Attribute, objc_class_name="alloc") +Attribute_alloc :: proc() -> ^Attribute { + return msgSend(^Attribute, Attribute, "alloc") +} +@(objc_type=Attribute, objc_name="init") +Attribute_init :: proc(self: ^Attribute) -> ^Attribute { + return msgSend(^Attribute, self, "init") +} +@(objc_type=Attribute, objc_name="attributeIndex") +Attribute_attributeIndex :: proc(self: ^Attribute) -> NS.Integer { + return msgSend(NS.Integer, self, "attributeIndex") +} +@(objc_type=Attribute, objc_name="attributeType") +Attribute_attributeType :: proc(self: ^Attribute) -> DataType { + return msgSend(DataType, self, "attributeType") +} +@(objc_type=Attribute, objc_name="isActive") +Attribute_isActive :: proc(self: ^Attribute) -> BOOL { + return msgSend(BOOL, self, "isActive") +} +@(objc_type=Attribute, objc_name="isPatchControlPointData") +Attribute_isPatchControlPointData :: proc(self: ^Attribute) -> BOOL { + return msgSend(BOOL, self, "isPatchControlPointData") +} +@(objc_type=Attribute, objc_name="isPatchData") +Attribute_isPatchData :: proc(self: ^Attribute) -> BOOL { + return msgSend(BOOL, self, "isPatchData") +} +@(objc_type=Attribute, objc_name="name") +Attribute_name :: proc(self: ^Attribute) -> ^NS.String { + return msgSend(^NS.String, self, "name") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + AttributeDescriptor +Class Methods: + alloc +Methods: + init + bufferIndex + format + offset + setBufferIndex + setFormat + setOffset +*/ +@(objc_class="MTLAttributeDescriptor") +AttributeDescriptor :: struct { using _: NS.Copying(AttributeDescriptor) } + +@(objc_type=AttributeDescriptor, objc_class_name="alloc") +AttributeDescriptor_alloc :: proc() -> ^AttributeDescriptor { + return msgSend(^AttributeDescriptor, AttributeDescriptor, "alloc") +} +@(objc_type=AttributeDescriptor, objc_name="init") +AttributeDescriptor_init :: proc(self: ^AttributeDescriptor) -> ^AttributeDescriptor { + return msgSend(^AttributeDescriptor, self, "init") +} +@(objc_type=AttributeDescriptor, objc_name="bufferIndex") +AttributeDescriptor_bufferIndex :: proc(self: ^AttributeDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "bufferIndex") +} +@(objc_type=AttributeDescriptor, objc_name="format") +AttributeDescriptor_format :: proc(self: ^AttributeDescriptor) -> AttributeFormat { + return msgSend(AttributeFormat, self, "format") +} +@(objc_type=AttributeDescriptor, objc_name="offset") +AttributeDescriptor_offset :: proc(self: ^AttributeDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "offset") +} +@(objc_type=AttributeDescriptor, objc_name="setBufferIndex") +AttributeDescriptor_setBufferIndex :: proc(self: ^AttributeDescriptor, bufferIndex: NS.Integer) { + msgSend(nil, self, "setBufferIndex:", bufferIndex) +} +@(objc_type=AttributeDescriptor, objc_name="setFormat") +AttributeDescriptor_setFormat :: proc(self: ^AttributeDescriptor, format: AttributeFormat) { + msgSend(nil, self, "setFormat:", format) +} +@(objc_type=AttributeDescriptor, objc_name="setOffset") +AttributeDescriptor_setOffset :: proc(self: ^AttributeDescriptor, offset: NS.Integer) { + msgSend(nil, self, "setOffset:", offset) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + AttributeDescriptorArray +Class Methods: + alloc +Methods: + init + objectAtIndexedSubscript + setObject +*/ +@(objc_class="MTLAttributeDescriptorArray") +AttributeDescriptorArray :: struct { using _: NS.Object } + +@(objc_type=AttributeDescriptorArray, objc_class_name="alloc") +AttributeDescriptorArray_alloc :: proc() -> ^AttributeDescriptorArray { + return msgSend(^AttributeDescriptorArray, AttributeDescriptorArray, "alloc") +} +@(objc_type=AttributeDescriptorArray, objc_name="init") +AttributeDescriptorArray_init :: proc(self: ^AttributeDescriptorArray) -> ^AttributeDescriptorArray { + return msgSend(^AttributeDescriptorArray, self, "init") +} +@(objc_type=AttributeDescriptorArray, objc_name="objectAtIndexedSubscript") +AttributeDescriptorArray_objectAtIndexedSubscript :: proc(self: ^AttributeDescriptorArray, index: ^NS.Object) -> ^AttributeDescriptor { + return msgSend(^AttributeDescriptor, self, "objectAtIndexedSubscript:", index) +} +@(objc_type=AttributeDescriptorArray, objc_name="setObject") +AttributeDescriptorArray_setObject :: proc(self: ^AttributeDescriptorArray, attributeDesc: ^AttributeDescriptor, index: ^NS.Object) { + msgSend(nil, self, "setObject:atIndexedSubscript:", attributeDesc, index) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + BinaryArchiveDescriptor +Class Methods: + alloc +Methods: + init + setUrl + url +*/ +@(objc_class="MTLBinaryArchiveDescriptor") +BinaryArchiveDescriptor :: struct { using _: NS.Copying(BinaryArchiveDescriptor) } + +@(objc_type=BinaryArchiveDescriptor, objc_class_name="alloc") +BinaryArchiveDescriptor_alloc :: proc() -> ^BinaryArchiveDescriptor { + return msgSend(^BinaryArchiveDescriptor, BinaryArchiveDescriptor, "alloc") +} +@(objc_type=BinaryArchiveDescriptor, objc_name="init") +BinaryArchiveDescriptor_init :: proc(self: ^BinaryArchiveDescriptor) -> ^BinaryArchiveDescriptor { + return msgSend(^BinaryArchiveDescriptor, self, "init") +} +@(objc_type=BinaryArchiveDescriptor, objc_name="setUrl") +BinaryArchiveDescriptor_setUrl :: proc(self: ^BinaryArchiveDescriptor, url: ^NS.URL) { + msgSend(nil, self, "setUrl:", url) +} +@(objc_type=BinaryArchiveDescriptor, objc_name="url") +BinaryArchiveDescriptor_url :: proc(self: ^BinaryArchiveDescriptor) -> ^NS.URL { + return msgSend(^NS.URL, self, "url") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + BlitPassDescriptor +Class Methods: + alloc + blitPassDescriptor +Methods: + init + sampleBufferAttachments +*/ +@(objc_class="MTLBlitPassDescriptor") +BlitPassDescriptor :: struct { using _: NS.Copying(BlitPassDescriptor) } + +@(objc_type=BlitPassDescriptor, objc_class_name="alloc") +BlitPassDescriptor_alloc :: proc() -> ^BlitPassDescriptor { + return msgSend(^BlitPassDescriptor, BlitPassDescriptor, "alloc") +} +@(objc_type=BlitPassDescriptor, objc_name="init") +BlitPassDescriptor_init :: proc(self: ^BlitPassDescriptor) -> ^BlitPassDescriptor { + return msgSend(^BlitPassDescriptor, self, "init") +} +@(objc_type=BlitPassDescriptor, objc_class_name="blitPassDescriptor") +BlitPassDescriptor_blitPassDescriptor :: proc() -> ^BlitPassDescriptor { + return msgSend(^BlitPassDescriptor, BlitPassDescriptor, "blitPassDescriptor") +} +@(objc_type=BlitPassDescriptor, objc_name="sampleBufferAttachments") +BlitPassDescriptor_sampleBufferAttachments :: proc(self: ^BlitPassDescriptor) -> ^BlitPassSampleBufferAttachmentDescriptorArray { + return msgSend(^BlitPassSampleBufferAttachmentDescriptorArray, self, "sampleBufferAttachments") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + BlitPassSampleBufferAttachmentDescriptor +Class Methods: + alloc +Methods: + init + endOfEncoderSampleIndex + sampleBuffer + setEndOfEncoderSampleIndex + setSampleBuffer + setStartOfEncoderSampleIndex + startOfEncoderSampleIndex +*/ +@(objc_class="MTLBlitPassSampleBufferAttachmentDescriptor") +BlitPassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(BlitPassSampleBufferAttachmentDescriptor) } + +@(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_class_name="alloc") +BlitPassSampleBufferAttachmentDescriptor_alloc :: proc() -> ^BlitPassSampleBufferAttachmentDescriptor { + return msgSend(^BlitPassSampleBufferAttachmentDescriptor, BlitPassSampleBufferAttachmentDescriptor, "alloc") +} +@(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="init") +BlitPassSampleBufferAttachmentDescriptor_init :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> ^BlitPassSampleBufferAttachmentDescriptor { + return msgSend(^BlitPassSampleBufferAttachmentDescriptor, self, "init") +} +@(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="endOfEncoderSampleIndex") +BlitPassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "endOfEncoderSampleIndex") +} +@(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") +BlitPassSampleBufferAttachmentDescriptor_sampleBuffer :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> ^BlitPassSampleBufferAttachmentDescriptor { + return msgSend(^BlitPassSampleBufferAttachmentDescriptor, self, "sampleBuffer") +} +@(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex") +BlitPassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.Integer) { + msgSend(nil, self, "setEndOfEncoderSampleIndex:", endOfEncoderSampleIndex) +} +@(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") +BlitPassSampleBufferAttachmentDescriptor_setSampleBuffer :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) { + msgSend(nil, self, "setSampleBuffer:", sampleBuffer) +} +@(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="setStartOfEncoderSampleIndex") +BlitPassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.Integer) { + msgSend(nil, self, "setStartOfEncoderSampleIndex:", startOfEncoderSampleIndex) +} +@(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="startOfEncoderSampleIndex") +BlitPassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "startOfEncoderSampleIndex") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + BlitPassSampleBufferAttachmentDescriptorArray +Class Methods: + alloc +Methods: + init + objectAtIndexedSubscript + setObject +*/ +@(objc_class="MTLBlitPassSampleBufferAttachmentDescriptorArray") +BlitPassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object } + +@(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_class_name="alloc") +BlitPassSampleBufferAttachmentDescriptorArray_alloc :: proc() -> ^BlitPassSampleBufferAttachmentDescriptorArray { + return msgSend(^BlitPassSampleBufferAttachmentDescriptorArray, BlitPassSampleBufferAttachmentDescriptorArray, "alloc") +} +@(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_name="init") +BlitPassSampleBufferAttachmentDescriptorArray_init :: proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray) -> ^BlitPassSampleBufferAttachmentDescriptorArray { + return msgSend(^BlitPassSampleBufferAttachmentDescriptorArray, self, "init") +} +@(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") +BlitPassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^BlitPassSampleBufferAttachmentDescriptor { + return msgSend(^BlitPassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) +} +@(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_name="setObject") +BlitPassSampleBufferAttachmentDescriptorArray_setObject :: proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray, attachment: ^BlitPassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) { + msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + BufferLayoutDescriptor +Class Methods: + alloc +Methods: + init + setStepFunction + setStepRate + setStride + stepFunction + stepRate + stride +*/ +@(objc_class="MTLBufferLayoutDescriptor") +BufferLayoutDescriptor :: struct { using _: NS.Copying(BufferLayoutDescriptor) } + +@(objc_type=BufferLayoutDescriptor, objc_class_name="alloc") +BufferLayoutDescriptor_alloc :: proc() -> ^BufferLayoutDescriptor { + return msgSend(^BufferLayoutDescriptor, BufferLayoutDescriptor, "alloc") +} +@(objc_type=BufferLayoutDescriptor, objc_name="init") +BufferLayoutDescriptor_init :: proc(self: ^BufferLayoutDescriptor) -> ^BufferLayoutDescriptor { + return msgSend(^BufferLayoutDescriptor, self, "init") +} +@(objc_type=BufferLayoutDescriptor, objc_name="setStepFunction") +BufferLayoutDescriptor_setStepFunction :: proc(self: ^BufferLayoutDescriptor, stepFunction: StepFunction) { + msgSend(nil, self, "setStepFunction:", stepFunction) +} +@(objc_type=BufferLayoutDescriptor, objc_name="setStepRate") +BufferLayoutDescriptor_setStepRate :: proc(self: ^BufferLayoutDescriptor, stepRate: NS.Integer) { + msgSend(nil, self, "setStepRate:", stepRate) +} +@(objc_type=BufferLayoutDescriptor, objc_name="setStride") +BufferLayoutDescriptor_setStride :: proc(self: ^BufferLayoutDescriptor, stride: NS.Integer) { + msgSend(nil, self, "setStride:", stride) +} +@(objc_type=BufferLayoutDescriptor, objc_name="stepFunction") +BufferLayoutDescriptor_stepFunction :: proc(self: ^BufferLayoutDescriptor) -> StepFunction { + return msgSend(StepFunction, self, "stepFunction") +} +@(objc_type=BufferLayoutDescriptor, objc_name="stepRate") +BufferLayoutDescriptor_stepRate :: proc(self: ^BufferLayoutDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "stepRate") +} +@(objc_type=BufferLayoutDescriptor, objc_name="stride") +BufferLayoutDescriptor_stride :: proc(self: ^BufferLayoutDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "stride") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + BufferLayoutDescriptorArray +Class Methods: + alloc +Methods: + init + objectAtIndexedSubscript + setObject +*/ +@(objc_class="MTLBufferLayoutDescriptorArray") +BufferLayoutDescriptorArray :: struct { using _: NS.Object } + +@(objc_type=BufferLayoutDescriptorArray, objc_class_name="alloc") +BufferLayoutDescriptorArray_alloc :: proc() -> ^BufferLayoutDescriptorArray { + return msgSend(^BufferLayoutDescriptorArray, BufferLayoutDescriptorArray, "alloc") +} +@(objc_type=BufferLayoutDescriptorArray, objc_name="init") +BufferLayoutDescriptorArray_init :: proc(self: ^BufferLayoutDescriptorArray) -> ^BufferLayoutDescriptorArray { + return msgSend(^BufferLayoutDescriptorArray, self, "init") +} +@(objc_type=BufferLayoutDescriptorArray, objc_name="objectAtIndexedSubscript") +BufferLayoutDescriptorArray_objectAtIndexedSubscript :: proc(self: ^BufferLayoutDescriptorArray, index: ^NS.Object) -> ^BufferLayoutDescriptor { + return msgSend(^BufferLayoutDescriptor, self, "objectAtIndexedSubscript:", index) +} +@(objc_type=BufferLayoutDescriptorArray, objc_name="setObject") +BufferLayoutDescriptorArray_setObject :: proc(self: ^BufferLayoutDescriptorArray, bufferDesc: ^BufferLayoutDescriptor, index: ^NS.Object) { + msgSend(nil, self, "setObject:atIndexedSubscript:", bufferDesc, index) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + CaptureDescriptor +Class Methods: + alloc +Methods: + init + captureObject + destination + outputURL + setCaptureObject + setDestination + setOutputURL +*/ +@(objc_class="MTLCaptureDescriptor") +CaptureDescriptor :: struct { using _: NS.Copying(CaptureDescriptor) } + +@(objc_type=CaptureDescriptor, objc_class_name="alloc") +CaptureDescriptor_alloc :: proc() -> ^CaptureDescriptor { + return msgSend(^CaptureDescriptor, CaptureDescriptor, "alloc") +} +@(objc_type=CaptureDescriptor, objc_name="init") +CaptureDescriptor_init :: proc(self: ^CaptureDescriptor) -> ^CaptureDescriptor { + return msgSend(^CaptureDescriptor, self, "init") +} +@(objc_type=CaptureDescriptor, objc_name="captureObject") +CaptureDescriptor_captureObject :: proc(self: ^CaptureDescriptor) -> ^CaptureDescriptor { + return msgSend(^CaptureDescriptor, self, "captureObject") +} +@(objc_type=CaptureDescriptor, objc_name="destination") +CaptureDescriptor_destination :: proc(self: ^CaptureDescriptor) -> CaptureDestination { + return msgSend(CaptureDestination, self, "destination") +} +@(objc_type=CaptureDescriptor, objc_name="outputURL") +CaptureDescriptor_outputURL :: proc(self: ^CaptureDescriptor) -> ^NS.URL { + return msgSend(^NS.URL, self, "outputURL") +} +@(objc_type=CaptureDescriptor, objc_name="setCaptureObject") +CaptureDescriptor_setCaptureObject :: proc(self: ^CaptureDescriptor, captureObject: ^NS.Object) { + msgSend(nil, self, "setCaptureObject:", captureObject) +} +@(objc_type=CaptureDescriptor, objc_name="setDestination") +CaptureDescriptor_setDestination :: proc(self: ^CaptureDescriptor, destination: CaptureDestination) { + msgSend(nil, self, "setDestination:", destination) +} +@(objc_type=CaptureDescriptor, objc_name="setOutputURL") +CaptureDescriptor_setOutputURL :: proc(self: ^CaptureDescriptor, outputURL: ^NS.URL) { + msgSend(nil, self, "setOutputURL:", outputURL) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + CaptureManager +Class Methods: + alloc + sharedCaptureManager +Methods: + defaultCaptureScope + init + isCapturing + newCaptureScopeWithCommandQueue + newCaptureScopeWithDevice + setDefaultCaptureScope + startCaptureWithCommandQueue + startCaptureWithDescriptor + startCaptureWithDevice + startCaptureWithScope + stopCapture + supportsDestination +*/ +@(objc_class="MTLCaptureManager") +CaptureManager :: struct { using _: NS.Object } + +@(objc_type=CaptureManager, objc_class_name="alloc") +CaptureManager_alloc :: proc() -> ^CaptureManager { + return msgSend(^CaptureManager, CaptureManager, "alloc") +} +@(objc_type=CaptureManager, objc_name="defaultCaptureScope") +CaptureManager_defaultCaptureScope :: proc(self: ^CaptureManager) -> ^CaptureManager { + return msgSend(^CaptureManager, self, "defaultCaptureScope") +} +@(objc_type=CaptureManager, objc_name="init") +CaptureManager_init :: proc(self: ^CaptureManager) -> ^CaptureManager { + return msgSend(^CaptureManager, self, "init") +} +@(objc_type=CaptureManager, objc_name="isCapturing") +CaptureManager_isCapturing :: proc(self: ^CaptureManager) -> BOOL { + return msgSend(BOOL, self, "isCapturing") +} +@(objc_type=CaptureManager, objc_name="newCaptureScopeWithCommandQueue") +CaptureManager_newCaptureScopeWithCommandQueue :: proc(self: ^CaptureManager, commandQueue: ^NS.Object) -> ^CaptureManager { + return msgSend(^CaptureManager, self, "newCaptureScopeWithCommandQueue:", commandQueue) +} +@(objc_type=CaptureManager, objc_name="newCaptureScopeWithDevice") +CaptureManager_newCaptureScopeWithDevice :: proc(self: ^CaptureManager, device: ^NS.Object) -> ^CaptureManager { + return msgSend(^CaptureManager, self, "newCaptureScopeWithDevice:", device) +} +@(objc_type=CaptureManager, objc_name="setDefaultCaptureScope") +CaptureManager_setDefaultCaptureScope :: proc(self: ^CaptureManager, defaultCaptureScope: ^NS.Object) { + msgSend(nil, self, "setDefaultCaptureScope:", defaultCaptureScope) +} +@(objc_type=CaptureManager, objc_class_name="sharedCaptureManager") +CaptureManager_sharedCaptureManager :: proc() -> ^CaptureManager { + return msgSend(^CaptureManager, CaptureManager, "sharedCaptureManager") +} +@(objc_type=CaptureManager, objc_name="startCaptureWithCommandQueue") +CaptureManager_startCaptureWithCommandQueue :: proc(self: ^CaptureManager, commandQueue: ^NS.Object) { + msgSend(nil, self, "startCaptureWithCommandQueue:", commandQueue) +} +@(objc_type=CaptureManager, objc_name="startCaptureWithDescriptor") +CaptureManager_startCaptureWithDescriptor :: proc(self: ^CaptureManager, descriptor: ^CaptureDescriptor, error: ^^NS.Error ) -> BOOL { + return msgSend(BOOL, self, "startCaptureWithDescriptor:error:", descriptor, error) +} +@(objc_type=CaptureManager, objc_name="startCaptureWithDevice") +CaptureManager_startCaptureWithDevice :: proc(self: ^CaptureManager, device: ^NS.Object) { + msgSend(nil, self, "startCaptureWithDevice:", device) +} +@(objc_type=CaptureManager, objc_name="startCaptureWithScope") +CaptureManager_startCaptureWithScope :: proc(self: ^CaptureManager, captureScope: ^NS.Object) { + msgSend(nil, self, "startCaptureWithScope:", captureScope) +} +@(objc_type=CaptureManager, objc_name="stopCapture") +CaptureManager_stopCapture :: proc(self: ^CaptureManager) { + msgSend(nil, self, "stopCapture") +} +@(objc_type=CaptureManager, objc_name="supportsDestination") +CaptureManager_supportsDestination :: proc(self: ^CaptureManager, destination: CaptureDestination) -> BOOL { + return msgSend(BOOL, self, "supportsDestination:", destination) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + CommandBufferDescriptor +Class Methods: + alloc +Methods: + init + errorOptions + retainedReferences + setErrorOptions + setRetainedReferences +*/ +@(objc_class="MTLCommandBufferDescriptor") +CommandBufferDescriptor :: struct { using _: NS.Copying(CommandBufferDescriptor) } + +@(objc_type=CommandBufferDescriptor, objc_class_name="alloc") +CommandBufferDescriptor_alloc :: proc() -> ^CommandBufferDescriptor { + return msgSend(^CommandBufferDescriptor, CommandBufferDescriptor, "alloc") +} +@(objc_type=CommandBufferDescriptor, objc_name="init") +CommandBufferDescriptor_init :: proc(self: ^CommandBufferDescriptor) -> ^CommandBufferDescriptor { + return msgSend(^CommandBufferDescriptor, self, "init") +} +@(objc_type=CommandBufferDescriptor, objc_name="errorOptions") +CommandBufferDescriptor_errorOptions :: proc(self: ^CommandBufferDescriptor) -> CommandBufferErrorOption { + return msgSend(CommandBufferErrorOption, self, "errorOptions") +} +@(objc_type=CommandBufferDescriptor, objc_name="retainedReferences") +CommandBufferDescriptor_retainedReferences :: proc(self: ^CommandBufferDescriptor) -> BOOL { + return msgSend(BOOL, self, "retainedReferences") +} +@(objc_type=CommandBufferDescriptor, objc_name="setErrorOptions") +CommandBufferDescriptor_setErrorOptions :: proc(self: ^CommandBufferDescriptor, errorOptions: CommandBufferErrorOption) { + msgSend(nil, self, "setErrorOptions:", errorOptions) +} +@(objc_type=CommandBufferDescriptor, objc_name="setRetainedReferences") +CommandBufferDescriptor_setRetainedReferences :: proc(self: ^CommandBufferDescriptor, retainedReferences: BOOL) { + msgSend(nil, self, "setRetainedReferences:", retainedReferences) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + CompileOptions +Class Methods: + alloc +Methods: + init + fastMathEnabled + installName + languageVersion + libraries + libraryType + preprocessorMacros + preserveInvariance + setFastMathEnabled + setInstallName + setLanguageVersion + setLibraries + setLibraryType + setPreprocessorMacros + setPreserveInvariance +*/ +@(objc_class="MTLCompileOptions") +CompileOptions :: struct { using _: NS.Copying(CompileOptions) } + +@(objc_type=CompileOptions, objc_class_name="alloc") +CompileOptions_alloc :: proc() -> ^CompileOptions { + return msgSend(^CompileOptions, CompileOptions, "alloc") +} +@(objc_type=CompileOptions, objc_name="init") +CompileOptions_init :: proc(self: ^CompileOptions) -> ^CompileOptions { + return msgSend(^CompileOptions, self, "init") +} +@(objc_type=CompileOptions, objc_name="fastMathEnabled") +CompileOptions_fastMathEnabled :: proc(self: ^CompileOptions) -> BOOL { + return msgSend(BOOL, self, "fastMathEnabled") +} +@(objc_type=CompileOptions, objc_name="installName") +CompileOptions_installName :: proc(self: ^CompileOptions) -> ^NS.String { + return msgSend(^NS.String, self, "installName") +} +@(objc_type=CompileOptions, objc_name="languageVersion") +CompileOptions_languageVersion :: proc(self: ^CompileOptions) -> LanguageVersion { + return msgSend(LanguageVersion, self, "languageVersion") +} +@(objc_type=CompileOptions, objc_name="libraries") +CompileOptions_libraries :: proc(self: ^CompileOptions) -> ^NS.Array { + return msgSend(^NS.Array, self, "libraries") +} +@(objc_type=CompileOptions, objc_name="libraryType") +CompileOptions_libraryType :: proc(self: ^CompileOptions) -> LibraryType { + return msgSend(LibraryType, self, "libraryType") +} +@(objc_type=CompileOptions, objc_name="preprocessorMacros") +CompileOptions_preprocessorMacros :: proc(self: ^CompileOptions) -> ^NS.Dictionary { + return msgSend(^NS.Dictionary, self, "preprocessorMacros") +} +@(objc_type=CompileOptions, objc_name="preserveInvariance") +CompileOptions_preserveInvariance :: proc(self: ^CompileOptions) -> BOOL { + return msgSend(BOOL, self, "preserveInvariance") +} +@(objc_type=CompileOptions, objc_name="setFastMathEnabled") +CompileOptions_setFastMathEnabled :: proc(self: ^CompileOptions, fastMathEnabled: BOOL) { + msgSend(nil, self, "setFastMathEnabled:", fastMathEnabled) +} +@(objc_type=CompileOptions, objc_name="setInstallName") +CompileOptions_setInstallName :: proc(self: ^CompileOptions, installName: ^NS.String) { + msgSend(nil, self, "setInstallName:", installName) +} +@(objc_type=CompileOptions, objc_name="setLanguageVersion") +CompileOptions_setLanguageVersion :: proc(self: ^CompileOptions, languageVersion: LanguageVersion) { + msgSend(nil, self, "setLanguageVersion:", languageVersion) +} +@(objc_type=CompileOptions, objc_name="setLibraries") +CompileOptions_setLibraries :: proc(self: ^CompileOptions, libraries: ^NS.Array) { + msgSend(nil, self, "setLibraries:", libraries) +} +@(objc_type=CompileOptions, objc_name="setLibraryType") +CompileOptions_setLibraryType :: proc(self: ^CompileOptions, libraryType: LibraryType) { + msgSend(nil, self, "setLibraryType:", libraryType) +} +@(objc_type=CompileOptions, objc_name="setPreprocessorMacros") +CompileOptions_setPreprocessorMacros :: proc(self: ^CompileOptions, preprocessorMacros: ^NS.Dictionary) { + msgSend(nil, self, "setPreprocessorMacros:", preprocessorMacros) +} +@(objc_type=CompileOptions, objc_name="setPreserveInvariance") +CompileOptions_setPreserveInvariance :: proc(self: ^CompileOptions, preserveInvariance: BOOL) { + msgSend(nil, self, "setPreserveInvariance:", preserveInvariance) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + ComputePassDescriptor +Class Methods: + alloc + computePassDescriptor +Methods: + init + dispatchType + sampleBufferAttachments + setDispatchType +*/ +@(objc_class="MTLComputePassDescriptor") +ComputePassDescriptor :: struct { using _: NS.Copying(ComputePassDescriptor) } + +@(objc_type=ComputePassDescriptor, objc_class_name="alloc") +ComputePassDescriptor_alloc :: proc() -> ^ComputePassDescriptor { + return msgSend(^ComputePassDescriptor, ComputePassDescriptor, "alloc") +} +@(objc_type=ComputePassDescriptor, objc_name="init") +ComputePassDescriptor_init :: proc(self: ^ComputePassDescriptor) -> ^ComputePassDescriptor { + return msgSend(^ComputePassDescriptor, self, "init") +} +@(objc_type=ComputePassDescriptor, objc_class_name="computePassDescriptor") +ComputePassDescriptor_computePassDescriptor :: proc() -> ^ComputePassDescriptor { + return msgSend(^ComputePassDescriptor, ComputePassDescriptor, "computePassDescriptor") +} +@(objc_type=ComputePassDescriptor, objc_name="dispatchType") +ComputePassDescriptor_dispatchType :: proc(self: ^ComputePassDescriptor) -> DispatchType { + return msgSend(DispatchType, self, "dispatchType") +} +@(objc_type=ComputePassDescriptor, objc_name="sampleBufferAttachments") +ComputePassDescriptor_sampleBufferAttachments :: proc(self: ^ComputePassDescriptor) -> ^ComputePassSampleBufferAttachmentDescriptorArray { + return msgSend(^ComputePassSampleBufferAttachmentDescriptorArray, self, "sampleBufferAttachments") +} +@(objc_type=ComputePassDescriptor, objc_name="setDispatchType") +ComputePassDescriptor_setDispatchType :: proc(self: ^ComputePassDescriptor, dispatchType: DispatchType) { + msgSend(nil, self, "setDispatchType:", dispatchType) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + ComputePassSampleBufferAttachmentDescriptor +Class Methods: + alloc +Methods: + init + endOfEncoderSampleIndex + sampleBuffer + setEndOfEncoderSampleIndex + setSampleBuffer + setStartOfEncoderSampleIndex + startOfEncoderSampleIndex +*/ +@(objc_class="MTLComputePassSampleBufferAttachmentDescriptor") +ComputePassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(ComputePassSampleBufferAttachmentDescriptor) } + +@(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_class_name="alloc") +ComputePassSampleBufferAttachmentDescriptor_alloc :: proc() -> ^ComputePassSampleBufferAttachmentDescriptor { + return msgSend(^ComputePassSampleBufferAttachmentDescriptor, ComputePassSampleBufferAttachmentDescriptor, "alloc") +} +@(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="init") +ComputePassSampleBufferAttachmentDescriptor_init :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> ^ComputePassSampleBufferAttachmentDescriptor { + return msgSend(^ComputePassSampleBufferAttachmentDescriptor, self, "init") +} +@(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="endOfEncoderSampleIndex") +ComputePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "endOfEncoderSampleIndex") +} +@(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") +ComputePassSampleBufferAttachmentDescriptor_sampleBuffer :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> ^ComputePassSampleBufferAttachmentDescriptor { + return msgSend(^ComputePassSampleBufferAttachmentDescriptor, self, "sampleBuffer") +} +@(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex") +ComputePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.Integer) { + msgSend(nil, self, "setEndOfEncoderSampleIndex:", endOfEncoderSampleIndex) +} +@(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") +ComputePassSampleBufferAttachmentDescriptor_setSampleBuffer :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) { + msgSend(nil, self, "setSampleBuffer:", sampleBuffer) +} +@(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="setStartOfEncoderSampleIndex") +ComputePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.Integer) { + msgSend(nil, self, "setStartOfEncoderSampleIndex:", startOfEncoderSampleIndex) +} +@(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="startOfEncoderSampleIndex") +ComputePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "startOfEncoderSampleIndex") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + ComputePassSampleBufferAttachmentDescriptorArray +Class Methods: + alloc +Methods: + init + objectAtIndexedSubscript + setObject +*/ +@(objc_class="MTLComputePassSampleBufferAttachmentDescriptorArray") +ComputePassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object } + +@(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_class_name="alloc") +ComputePassSampleBufferAttachmentDescriptorArray_alloc :: proc() -> ^ComputePassSampleBufferAttachmentDescriptorArray { + return msgSend(^ComputePassSampleBufferAttachmentDescriptorArray, ComputePassSampleBufferAttachmentDescriptorArray, "alloc") +} +@(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_name="init") +ComputePassSampleBufferAttachmentDescriptorArray_init :: proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray) -> ^ComputePassSampleBufferAttachmentDescriptorArray { + return msgSend(^ComputePassSampleBufferAttachmentDescriptorArray, self, "init") +} +@(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") +ComputePassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^ComputePassSampleBufferAttachmentDescriptor { + return msgSend(^ComputePassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) +} +@(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_name="setObject") +ComputePassSampleBufferAttachmentDescriptorArray_setObject :: proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray, attachment: ^ComputePassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) { + msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + ComputePipelineDescriptor +Class Methods: + alloc +Methods: + init + binaryArchives + buffers + computeFunction + insertLibraries + label + linkedFunctions + maxCallStackDepth + maxTotalThreadsPerThreadgroup + reset + setBinaryArchives + setComputeFunction + setInsertLibraries + setLabel + setLinkedFunctions + setMaxCallStackDepth + setMaxTotalThreadsPerThreadgroup + setStageInputDescriptor + setSupportAddingBinaryFunctions + setSupportIndirectCommandBuffers + setThreadGroupSizeIsMultipleOfThreadExecutionWidth + stageInputDescriptor + supportAddingBinaryFunctions + supportIndirectCommandBuffers + threadGroupSizeIsMultipleOfThreadExecutionWidth +*/ +@(objc_class="MTLComputePipelineDescriptor") +ComputePipelineDescriptor :: struct { using _: NS.Copying(ComputePipelineDescriptor) } + +@(objc_type=ComputePipelineDescriptor, objc_class_name="alloc") +ComputePipelineDescriptor_alloc :: proc() -> ^ComputePipelineDescriptor { + return msgSend(^ComputePipelineDescriptor, ComputePipelineDescriptor, "alloc") +} +@(objc_type=ComputePipelineDescriptor, objc_name="init") +ComputePipelineDescriptor_init :: proc(self: ^ComputePipelineDescriptor) -> ^ComputePipelineDescriptor { + return msgSend(^ComputePipelineDescriptor, self, "init") +} +@(objc_type=ComputePipelineDescriptor, objc_name="binaryArchives") +ComputePipelineDescriptor_binaryArchives :: proc(self: ^ComputePipelineDescriptor) -> ^NS.Array { + return msgSend(^NS.Array, self, "binaryArchives") +} +@(objc_type=ComputePipelineDescriptor, objc_name="buffers") +ComputePipelineDescriptor_buffers :: proc(self: ^ComputePipelineDescriptor) -> ^PipelineBufferDescriptorArray { + return msgSend(^PipelineBufferDescriptorArray, self, "buffers") +} +@(objc_type=ComputePipelineDescriptor, objc_name="computeFunction") +ComputePipelineDescriptor_computeFunction :: proc(self: ^ComputePipelineDescriptor) -> ^ComputePipelineDescriptor { + return msgSend(^ComputePipelineDescriptor, self, "computeFunction") +} +@(objc_type=ComputePipelineDescriptor, objc_name="insertLibraries") +ComputePipelineDescriptor_insertLibraries :: proc(self: ^ComputePipelineDescriptor) -> ^NS.Array { + return msgSend(^NS.Array, self, "insertLibraries") +} +@(objc_type=ComputePipelineDescriptor, objc_name="label") +ComputePipelineDescriptor_label :: proc(self: ^ComputePipelineDescriptor) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=ComputePipelineDescriptor, objc_name="linkedFunctions") +ComputePipelineDescriptor_linkedFunctions :: proc(self: ^ComputePipelineDescriptor) -> ^LinkedFunctions { + return msgSend(^LinkedFunctions, self, "linkedFunctions") +} +@(objc_type=ComputePipelineDescriptor, objc_name="maxCallStackDepth") +ComputePipelineDescriptor_maxCallStackDepth :: proc(self: ^ComputePipelineDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "maxCallStackDepth") +} +@(objc_type=ComputePipelineDescriptor, objc_name="maxTotalThreadsPerThreadgroup") +ComputePipelineDescriptor_maxTotalThreadsPerThreadgroup :: proc(self: ^ComputePipelineDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "maxTotalThreadsPerThreadgroup") +} +@(objc_type=ComputePipelineDescriptor, objc_name="reset") +ComputePipelineDescriptor_reset :: proc(self: ^ComputePipelineDescriptor) { + msgSend(nil, self, "reset") +} +@(objc_type=ComputePipelineDescriptor, objc_name="setBinaryArchives") +ComputePipelineDescriptor_setBinaryArchives :: proc(self: ^ComputePipelineDescriptor, binaryArchives: ^NS.Array) { + msgSend(nil, self, "setBinaryArchives:", binaryArchives) +} +@(objc_type=ComputePipelineDescriptor, objc_name="setComputeFunction") +ComputePipelineDescriptor_setComputeFunction :: proc(self: ^ComputePipelineDescriptor, computeFunction: ^NS.Object) { + msgSend(nil, self, "setComputeFunction:", computeFunction) +} +@(objc_type=ComputePipelineDescriptor, objc_name="setInsertLibraries") +ComputePipelineDescriptor_setInsertLibraries :: proc(self: ^ComputePipelineDescriptor, insertLibraries: ^NS.Array) { + msgSend(nil, self, "setInsertLibraries:", insertLibraries) +} +@(objc_type=ComputePipelineDescriptor, objc_name="setLabel") +ComputePipelineDescriptor_setLabel :: proc(self: ^ComputePipelineDescriptor, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} +@(objc_type=ComputePipelineDescriptor, objc_name="setLinkedFunctions") +ComputePipelineDescriptor_setLinkedFunctions :: proc(self: ^ComputePipelineDescriptor, linkedFunctions: ^LinkedFunctions) { + msgSend(nil, self, "setLinkedFunctions:", linkedFunctions) +} +@(objc_type=ComputePipelineDescriptor, objc_name="setMaxCallStackDepth") +ComputePipelineDescriptor_setMaxCallStackDepth :: proc(self: ^ComputePipelineDescriptor, maxCallStackDepth: NS.Integer) { + msgSend(nil, self, "setMaxCallStackDepth:", maxCallStackDepth) +} +@(objc_type=ComputePipelineDescriptor, objc_name="setMaxTotalThreadsPerThreadgroup") +ComputePipelineDescriptor_setMaxTotalThreadsPerThreadgroup :: proc(self: ^ComputePipelineDescriptor, maxTotalThreadsPerThreadgroup: NS.Integer) { + msgSend(nil, self, "setMaxTotalThreadsPerThreadgroup:", maxTotalThreadsPerThreadgroup) +} +@(objc_type=ComputePipelineDescriptor, objc_name="setStageInputDescriptor") +ComputePipelineDescriptor_setStageInputDescriptor :: proc(self: ^ComputePipelineDescriptor, stageInputDescriptor: ^StageInputOutputDescriptor) { + msgSend(nil, self, "setStageInputDescriptor:", stageInputDescriptor) +} +@(objc_type=ComputePipelineDescriptor, objc_name="setSupportAddingBinaryFunctions") +ComputePipelineDescriptor_setSupportAddingBinaryFunctions :: proc(self: ^ComputePipelineDescriptor, supportAddingBinaryFunctions: BOOL) { + msgSend(nil, self, "setSupportAddingBinaryFunctions:", supportAddingBinaryFunctions) +} +@(objc_type=ComputePipelineDescriptor, objc_name="setSupportIndirectCommandBuffers") +ComputePipelineDescriptor_setSupportIndirectCommandBuffers :: proc(self: ^ComputePipelineDescriptor, supportIndirectCommandBuffers: BOOL) { + msgSend(nil, self, "setSupportIndirectCommandBuffers:", supportIndirectCommandBuffers) +} +@(objc_type=ComputePipelineDescriptor, objc_name="setThreadGroupSizeIsMultipleOfThreadExecutionWidth") +ComputePipelineDescriptor_setThreadGroupSizeIsMultipleOfThreadExecutionWidth :: proc(self: ^ComputePipelineDescriptor, threadGroupSizeIsMultipleOfThreadExecutionWidth: BOOL) { + msgSend(nil, self, "setThreadGroupSizeIsMultipleOfThreadExecutionWidth:", threadGroupSizeIsMultipleOfThreadExecutionWidth) +} +@(objc_type=ComputePipelineDescriptor, objc_name="stageInputDescriptor") +ComputePipelineDescriptor_stageInputDescriptor :: proc(self: ^ComputePipelineDescriptor) -> ^StageInputOutputDescriptor { + return msgSend(^StageInputOutputDescriptor, self, "stageInputDescriptor") +} +@(objc_type=ComputePipelineDescriptor, objc_name="supportAddingBinaryFunctions") +ComputePipelineDescriptor_supportAddingBinaryFunctions :: proc(self: ^ComputePipelineDescriptor) -> BOOL { + return msgSend(BOOL, self, "supportAddingBinaryFunctions") +} +@(objc_type=ComputePipelineDescriptor, objc_name="supportIndirectCommandBuffers") +ComputePipelineDescriptor_supportIndirectCommandBuffers :: proc(self: ^ComputePipelineDescriptor) -> BOOL { + return msgSend(BOOL, self, "supportIndirectCommandBuffers") +} +@(objc_type=ComputePipelineDescriptor, objc_name="threadGroupSizeIsMultipleOfThreadExecutionWidth") +ComputePipelineDescriptor_threadGroupSizeIsMultipleOfThreadExecutionWidth :: proc(self: ^ComputePipelineDescriptor) -> BOOL { + return msgSend(BOOL, self, "threadGroupSizeIsMultipleOfThreadExecutionWidth") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + ComputePipelineReflection +Class Methods: + alloc +Methods: + init + arguments +*/ +@(objc_class="MTLComputePipelineReflection") +ComputePipelineReflection :: struct { using _: NS.Object } + +@(objc_type=ComputePipelineReflection, objc_class_name="alloc") +ComputePipelineReflection_alloc :: proc() -> ^ComputePipelineReflection { + return msgSend(^ComputePipelineReflection, ComputePipelineReflection, "alloc") +} +@(objc_type=ComputePipelineReflection, objc_name="init") +ComputePipelineReflection_init :: proc(self: ^ComputePipelineReflection) -> ^ComputePipelineReflection { + return msgSend(^ComputePipelineReflection, self, "init") +} +@(objc_type=ComputePipelineReflection, objc_name="arguments") +ComputePipelineReflection_arguments :: proc(self: ^ComputePipelineReflection) -> ^NS.Array { + return msgSend(^NS.Array, self, "arguments") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + CounterSampleBufferDescriptor +Class Methods: + alloc +Methods: + init + counterSet + label + sampleCount + setCounterSet + setLabel + setSampleCount + setStorageMode + storageMode +*/ +@(objc_class="MTLCounterSampleBufferDescriptor") +CounterSampleBufferDescriptor :: struct { using _: NS.Copying(CounterSampleBufferDescriptor) } + +@(objc_type=CounterSampleBufferDescriptor, objc_class_name="alloc") +CounterSampleBufferDescriptor_alloc :: proc() -> ^CounterSampleBufferDescriptor { + return msgSend(^CounterSampleBufferDescriptor, CounterSampleBufferDescriptor, "alloc") +} +@(objc_type=CounterSampleBufferDescriptor, objc_name="init") +CounterSampleBufferDescriptor_init :: proc(self: ^CounterSampleBufferDescriptor) -> ^CounterSampleBufferDescriptor { + return msgSend(^CounterSampleBufferDescriptor, self, "init") +} +@(objc_type=CounterSampleBufferDescriptor, objc_name="counterSet") +CounterSampleBufferDescriptor_counterSet :: proc(self: ^CounterSampleBufferDescriptor) -> ^CounterSampleBufferDescriptor { + return msgSend(^CounterSampleBufferDescriptor, self, "counterSet") +} +@(objc_type=CounterSampleBufferDescriptor, objc_name="label") +CounterSampleBufferDescriptor_label :: proc(self: ^CounterSampleBufferDescriptor) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=CounterSampleBufferDescriptor, objc_name="sampleCount") +CounterSampleBufferDescriptor_sampleCount :: proc(self: ^CounterSampleBufferDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "sampleCount") +} +@(objc_type=CounterSampleBufferDescriptor, objc_name="setCounterSet") +CounterSampleBufferDescriptor_setCounterSet :: proc(self: ^CounterSampleBufferDescriptor, counterSet: ^NS.Object) { + msgSend(nil, self, "setCounterSet:", counterSet) +} +@(objc_type=CounterSampleBufferDescriptor, objc_name="setLabel") +CounterSampleBufferDescriptor_setLabel :: proc(self: ^CounterSampleBufferDescriptor, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} +@(objc_type=CounterSampleBufferDescriptor, objc_name="setSampleCount") +CounterSampleBufferDescriptor_setSampleCount :: proc(self: ^CounterSampleBufferDescriptor, sampleCount: NS.Integer) { + msgSend(nil, self, "setSampleCount:", sampleCount) +} +@(objc_type=CounterSampleBufferDescriptor, objc_name="setStorageMode") +CounterSampleBufferDescriptor_setStorageMode :: proc(self: ^CounterSampleBufferDescriptor, storageMode: StorageMode) { + msgSend(nil, self, "setStorageMode:", storageMode) +} +@(objc_type=CounterSampleBufferDescriptor, objc_name="storageMode") +CounterSampleBufferDescriptor_storageMode :: proc(self: ^CounterSampleBufferDescriptor) -> StorageMode { + return msgSend(StorageMode, self, "storageMode") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + DepthStencilDescriptor +Class Methods: + alloc +Methods: + init + backFaceStencil + depthCompareFunction + frontFaceStencil + isDepthWriteEnabled + label + setBackFaceStencil + setDepthCompareFunction + setDepthWriteEnabled + setFrontFaceStencil + setLabel +*/ +@(objc_class="MTLDepthStencilDescriptor") +DepthStencilDescriptor :: struct { using _: NS.Copying(DepthStencilDescriptor) } + +@(objc_type=DepthStencilDescriptor, objc_class_name="alloc") +DepthStencilDescriptor_alloc :: proc() -> ^DepthStencilDescriptor { + return msgSend(^DepthStencilDescriptor, DepthStencilDescriptor, "alloc") +} +@(objc_type=DepthStencilDescriptor, objc_name="init") +DepthStencilDescriptor_init :: proc(self: ^DepthStencilDescriptor) -> ^DepthStencilDescriptor { + return msgSend(^DepthStencilDescriptor, self, "init") +} +@(objc_type=DepthStencilDescriptor, objc_name="backFaceStencil") +DepthStencilDescriptor_backFaceStencil :: proc(self: ^DepthStencilDescriptor) -> ^StencilDescriptor { + return msgSend(^StencilDescriptor, self, "backFaceStencil") +} +@(objc_type=DepthStencilDescriptor, objc_name="depthCompareFunction") +DepthStencilDescriptor_depthCompareFunction :: proc(self: ^DepthStencilDescriptor) -> CompareFunction { + return msgSend(CompareFunction, self, "depthCompareFunction") +} +@(objc_type=DepthStencilDescriptor, objc_name="frontFaceStencil") +DepthStencilDescriptor_frontFaceStencil :: proc(self: ^DepthStencilDescriptor) -> ^StencilDescriptor { + return msgSend(^StencilDescriptor, self, "frontFaceStencil") +} +@(objc_type=DepthStencilDescriptor, objc_name="isDepthWriteEnabled") +DepthStencilDescriptor_isDepthWriteEnabled :: proc(self: ^DepthStencilDescriptor) -> BOOL { + return msgSend(BOOL, self, "isDepthWriteEnabled") +} +@(objc_type=DepthStencilDescriptor, objc_name="label") +DepthStencilDescriptor_label :: proc(self: ^DepthStencilDescriptor) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=DepthStencilDescriptor, objc_name="setBackFaceStencil") +DepthStencilDescriptor_setBackFaceStencil :: proc(self: ^DepthStencilDescriptor, backFaceStencil: ^StencilDescriptor) { + msgSend(nil, self, "setBackFaceStencil:", backFaceStencil) +} +@(objc_type=DepthStencilDescriptor, objc_name="setDepthCompareFunction") +DepthStencilDescriptor_setDepthCompareFunction :: proc(self: ^DepthStencilDescriptor, depthCompareFunction: CompareFunction) { + msgSend(nil, self, "setDepthCompareFunction:", depthCompareFunction) +} +@(objc_type=DepthStencilDescriptor, objc_name="setDepthWriteEnabled") +DepthStencilDescriptor_setDepthWriteEnabled :: proc(self: ^DepthStencilDescriptor, depthWriteEnabled: BOOL) { + msgSend(nil, self, "setDepthWriteEnabled:", depthWriteEnabled) +} +@(objc_type=DepthStencilDescriptor, objc_name="setFrontFaceStencil") +DepthStencilDescriptor_setFrontFaceStencil :: proc(self: ^DepthStencilDescriptor, frontFaceStencil: ^StencilDescriptor) { + msgSend(nil, self, "setFrontFaceStencil:", frontFaceStencil) +} +@(objc_type=DepthStencilDescriptor, objc_name="setLabel") +DepthStencilDescriptor_setLabel :: proc(self: ^DepthStencilDescriptor, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + FunctionConstant +Class Methods: + alloc +Methods: + init + index + name + required + type +*/ +@(objc_class="MTLFunctionConstant") +FunctionConstant :: struct { using _: NS.Copying(FunctionConstant) } + +@(objc_type=FunctionConstant, objc_class_name="alloc") +FunctionConstant_alloc :: proc() -> ^FunctionConstant { + return msgSend(^FunctionConstant, FunctionConstant, "alloc") +} +@(objc_type=FunctionConstant, objc_name="init") +FunctionConstant_init :: proc(self: ^FunctionConstant) -> ^FunctionConstant { + return msgSend(^FunctionConstant, self, "init") +} +@(objc_type=FunctionConstant, objc_name="index") +FunctionConstant_index :: proc(self: ^FunctionConstant) -> NS.Integer { + return msgSend(NS.Integer, self, "index") +} +@(objc_type=FunctionConstant, objc_name="name") +FunctionConstant_name :: proc(self: ^FunctionConstant) -> ^NS.String { + return msgSend(^NS.String, self, "name") +} +@(objc_type=FunctionConstant, objc_name="required") +FunctionConstant_required :: proc(self: ^FunctionConstant) -> BOOL { + return msgSend(BOOL, self, "required") +} +@(objc_type=FunctionConstant, objc_name="type") +FunctionConstant_type :: proc(self: ^FunctionConstant) -> DataType { + return msgSend(DataType, self, "type") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + FunctionConstantValues +Class Methods: + alloc +Methods: + init + reset + setConstantValue + setConstantValue + setConstantValues +*/ +@(objc_class="MTLFunctionConstantValues") +FunctionConstantValues :: struct { using _: NS.Copying(FunctionConstantValues) } + +@(objc_type=FunctionConstantValues, objc_class_name="alloc") +FunctionConstantValues_alloc :: proc() -> ^FunctionConstantValues { + return msgSend(^FunctionConstantValues, FunctionConstantValues, "alloc") +} +@(objc_type=FunctionConstantValues, objc_name="init") +FunctionConstantValues_init :: proc(self: ^FunctionConstantValues) -> ^FunctionConstantValues { + return msgSend(^FunctionConstantValues, self, "init") +} +@(objc_type=FunctionConstantValues, objc_name="reset") +FunctionConstantValues_reset :: proc(self: ^FunctionConstantValues) { + msgSend(nil, self, "reset") +} +@(objc_type=FunctionConstantValues, objc_name="setConstantValue_type_atIndex_") +FunctionConstantValues_setConstantValue_type_atIndex_ :: proc(self: ^FunctionConstantValues, value: rawptr, type: DataType, index: ^NS.Object) { + msgSend(nil, self, "setConstantValue:type:atIndex:", value, type, index) +} +@(objc_type=FunctionConstantValues, objc_name="setConstantValue_type_withName_") +FunctionConstantValues_setConstantValue_type_withName_ :: proc(self: ^FunctionConstantValues, value: rawptr, type: DataType, name: ^NS.String) { + msgSend(nil, self, "setConstantValue:type:withName:", value, type, name) +} +@(objc_type=FunctionConstantValues, objc_name="setConstantValues") +FunctionConstantValues_setConstantValues :: proc(self: ^FunctionConstantValues, values: rawptr, type: DataType, range: NS.Range) { + msgSend(nil, self, "setConstantValues:type:withRange:", values, type, range) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + FunctionDescriptor +Class Methods: + alloc + functionDescriptor +Methods: + init + constantValues + name + options + setConstantValues + setName + setOptions + setSpecializedName + specializedName +*/ +@(objc_class="MTLFunctionDescriptor") +FunctionDescriptor :: struct { using _: NS.Copying(FunctionDescriptor) } + +@(objc_type=FunctionDescriptor, objc_class_name="alloc") +FunctionDescriptor_alloc :: proc() -> ^FunctionDescriptor { + return msgSend(^FunctionDescriptor, FunctionDescriptor, "alloc") +} +@(objc_type=FunctionDescriptor, objc_name="init") +FunctionDescriptor_init :: proc(self: ^FunctionDescriptor) -> ^FunctionDescriptor { + return msgSend(^FunctionDescriptor, self, "init") +} +@(objc_type=FunctionDescriptor, objc_name="constantValues") +FunctionDescriptor_constantValues :: proc(self: ^FunctionDescriptor) -> ^FunctionConstantValues { + return msgSend(^FunctionConstantValues, self, "constantValues") +} +@(objc_type=FunctionDescriptor, objc_class_name="functionDescriptor") +FunctionDescriptor_functionDescriptor :: proc() -> ^FunctionDescriptor { + return msgSend(^FunctionDescriptor, FunctionDescriptor, "functionDescriptor") +} +@(objc_type=FunctionDescriptor, objc_name="name") +FunctionDescriptor_name :: proc(self: ^FunctionDescriptor) -> ^NS.String { + return msgSend(^NS.String, self, "name") +} +@(objc_type=FunctionDescriptor, objc_name="options") +FunctionDescriptor_options :: proc(self: ^FunctionDescriptor) -> FunctionOptions { + return msgSend(FunctionOptions, self, "options") +} +@(objc_type=FunctionDescriptor, objc_name="setConstantValues") +FunctionDescriptor_setConstantValues :: proc(self: ^FunctionDescriptor, constantValues: ^FunctionConstantValues) { + msgSend(nil, self, "setConstantValues:", constantValues) +} +@(objc_type=FunctionDescriptor, objc_name="setName") +FunctionDescriptor_setName :: proc(self: ^FunctionDescriptor, name: ^NS.String) { + msgSend(nil, self, "setName:", name) +} +@(objc_type=FunctionDescriptor, objc_name="setOptions") +FunctionDescriptor_setOptions :: proc(self: ^FunctionDescriptor, options: FunctionOptions) { + msgSend(nil, self, "setOptions:", options) +} +@(objc_type=FunctionDescriptor, objc_name="setSpecializedName") +FunctionDescriptor_setSpecializedName :: proc(self: ^FunctionDescriptor, specializedName: ^NS.String) { + msgSend(nil, self, "setSpecializedName:", specializedName) +} +@(objc_type=FunctionDescriptor, objc_name="specializedName") +FunctionDescriptor_specializedName :: proc(self: ^FunctionDescriptor) -> ^NS.String { + return msgSend(^NS.String, self, "specializedName") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + IntersectionFunctionDescriptor +Class Methods: + alloc +Methods: + init +*/ +@(objc_class="MTLIntersectionFunctionDescriptor") +IntersectionFunctionDescriptor :: struct { using _: NS.Copying(IntersectionFunctionDescriptor) } + +@(objc_type=IntersectionFunctionDescriptor, objc_class_name="alloc") +IntersectionFunctionDescriptor_alloc :: proc() -> ^IntersectionFunctionDescriptor { + return msgSend(^IntersectionFunctionDescriptor, IntersectionFunctionDescriptor, "alloc") +} +@(objc_type=IntersectionFunctionDescriptor, objc_name="init") +IntersectionFunctionDescriptor_init :: proc(self: ^IntersectionFunctionDescriptor) -> ^IntersectionFunctionDescriptor { + return msgSend(^IntersectionFunctionDescriptor, self, "init") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + HeapDescriptor +Class Methods: + alloc +Methods: + init + cpuCacheMode + hazardTrackingMode + resourceOptions + setCpuCacheMode + setHazardTrackingMode + setResourceOptions + setSize + setStorageMode + setType + size + storageMode + type +*/ +@(objc_class="MTLHeapDescriptor") +HeapDescriptor :: struct { using _: NS.Copying(HeapDescriptor) } + +@(objc_type=HeapDescriptor, objc_class_name="alloc") +HeapDescriptor_alloc :: proc() -> ^HeapDescriptor { + return msgSend(^HeapDescriptor, HeapDescriptor, "alloc") +} +@(objc_type=HeapDescriptor, objc_name="init") +HeapDescriptor_init :: proc(self: ^HeapDescriptor) -> ^HeapDescriptor { + return msgSend(^HeapDescriptor, self, "init") +} +@(objc_type=HeapDescriptor, objc_name="cpuCacheMode") +HeapDescriptor_cpuCacheMode :: proc(self: ^HeapDescriptor) -> CPUCacheMode { + return msgSend(CPUCacheMode, self, "cpuCacheMode") +} +@(objc_type=HeapDescriptor, objc_name="hazardTrackingMode") +HeapDescriptor_hazardTrackingMode :: proc(self: ^HeapDescriptor) -> HazardTrackingMode { + return msgSend(HazardTrackingMode, self, "hazardTrackingMode") +} +@(objc_type=HeapDescriptor, objc_name="resourceOptions") +HeapDescriptor_resourceOptions :: proc(self: ^HeapDescriptor) -> ResourceOptions { + return msgSend(ResourceOptions, self, "resourceOptions") +} +@(objc_type=HeapDescriptor, objc_name="setCpuCacheMode") +HeapDescriptor_setCpuCacheMode :: proc(self: ^HeapDescriptor, cpuCacheMode: CPUCacheMode) { + msgSend(nil, self, "setCpuCacheMode:", cpuCacheMode) +} +@(objc_type=HeapDescriptor, objc_name="setHazardTrackingMode") +HeapDescriptor_setHazardTrackingMode :: proc(self: ^HeapDescriptor, hazardTrackingMode: HazardTrackingMode) { + msgSend(nil, self, "setHazardTrackingMode:", hazardTrackingMode) +} +@(objc_type=HeapDescriptor, objc_name="setResourceOptions") +HeapDescriptor_setResourceOptions :: proc(self: ^HeapDescriptor, resourceOptions: ResourceOptions) { + msgSend(nil, self, "setResourceOptions:", resourceOptions) +} +@(objc_type=HeapDescriptor, objc_name="setSize") +HeapDescriptor_setSize :: proc(self: ^HeapDescriptor, size: NS.Integer) { + msgSend(nil, self, "setSize:", size) +} +@(objc_type=HeapDescriptor, objc_name="setStorageMode") +HeapDescriptor_setStorageMode :: proc(self: ^HeapDescriptor, storageMode: StorageMode) { + msgSend(nil, self, "setStorageMode:", storageMode) +} +@(objc_type=HeapDescriptor, objc_name="setType") +HeapDescriptor_setType :: proc(self: ^HeapDescriptor, type: HeapType) { + msgSend(nil, self, "setType:", type) +} +@(objc_type=HeapDescriptor, objc_name="size") +HeapDescriptor_size :: proc(self: ^HeapDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "size") +} +@(objc_type=HeapDescriptor, objc_name="storageMode") +HeapDescriptor_storageMode :: proc(self: ^HeapDescriptor) -> StorageMode { + return msgSend(StorageMode, self, "storageMode") +} +@(objc_type=HeapDescriptor, objc_name="type") +HeapDescriptor_type :: proc(self: ^HeapDescriptor) -> HeapType { + return msgSend(HeapType, self, "type") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + IndirectCommandBufferDescriptor +Class Methods: + alloc +Methods: + init + commandTypes + inheritBuffers + inheritPipelineState + maxFragmentBufferBindCount + maxKernelBufferBindCount + maxVertexBufferBindCount + setCommandTypes + setInheritBuffers + setInheritPipelineState + setMaxFragmentBufferBindCount + setMaxKernelBufferBindCount + setMaxVertexBufferBindCount +*/ +@(objc_class="MTLIndirectCommandBufferDescriptor") +IndirectCommandBufferDescriptor :: struct { using _: NS.Copying(IndirectCommandBufferDescriptor) } + +@(objc_type=IndirectCommandBufferDescriptor, objc_class_name="alloc") +IndirectCommandBufferDescriptor_alloc :: proc() -> ^IndirectCommandBufferDescriptor { + return msgSend(^IndirectCommandBufferDescriptor, IndirectCommandBufferDescriptor, "alloc") +} +@(objc_type=IndirectCommandBufferDescriptor, objc_name="init") +IndirectCommandBufferDescriptor_init :: proc(self: ^IndirectCommandBufferDescriptor) -> ^IndirectCommandBufferDescriptor { + return msgSend(^IndirectCommandBufferDescriptor, self, "init") +} +@(objc_type=IndirectCommandBufferDescriptor, objc_name="commandTypes") +IndirectCommandBufferDescriptor_commandTypes :: proc(self: ^IndirectCommandBufferDescriptor) -> IndirectCommandType { + return msgSend(IndirectCommandType, self, "commandTypes") +} +@(objc_type=IndirectCommandBufferDescriptor, objc_name="inheritBuffers") +IndirectCommandBufferDescriptor_inheritBuffers :: proc(self: ^IndirectCommandBufferDescriptor) -> BOOL { + return msgSend(BOOL, self, "inheritBuffers") +} +@(objc_type=IndirectCommandBufferDescriptor, objc_name="inheritPipelineState") +IndirectCommandBufferDescriptor_inheritPipelineState :: proc(self: ^IndirectCommandBufferDescriptor) -> BOOL { + return msgSend(BOOL, self, "inheritPipelineState") +} +@(objc_type=IndirectCommandBufferDescriptor, objc_name="maxFragmentBufferBindCount") +IndirectCommandBufferDescriptor_maxFragmentBufferBindCount :: proc(self: ^IndirectCommandBufferDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "maxFragmentBufferBindCount") +} +@(objc_type=IndirectCommandBufferDescriptor, objc_name="maxKernelBufferBindCount") +IndirectCommandBufferDescriptor_maxKernelBufferBindCount :: proc(self: ^IndirectCommandBufferDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "maxKernelBufferBindCount") +} +@(objc_type=IndirectCommandBufferDescriptor, objc_name="maxVertexBufferBindCount") +IndirectCommandBufferDescriptor_maxVertexBufferBindCount :: proc(self: ^IndirectCommandBufferDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "maxVertexBufferBindCount") +} +@(objc_type=IndirectCommandBufferDescriptor, objc_name="setCommandTypes") +IndirectCommandBufferDescriptor_setCommandTypes :: proc(self: ^IndirectCommandBufferDescriptor, commandTypes: IndirectCommandType) { + msgSend(nil, self, "setCommandTypes:", commandTypes) +} +@(objc_type=IndirectCommandBufferDescriptor, objc_name="setInheritBuffers") +IndirectCommandBufferDescriptor_setInheritBuffers :: proc(self: ^IndirectCommandBufferDescriptor, inheritBuffers: BOOL) { + msgSend(nil, self, "setInheritBuffers:", inheritBuffers) +} +@(objc_type=IndirectCommandBufferDescriptor, objc_name="setInheritPipelineState") +IndirectCommandBufferDescriptor_setInheritPipelineState :: proc(self: ^IndirectCommandBufferDescriptor, inheritPipelineState: BOOL) { + msgSend(nil, self, "setInheritPipelineState:", inheritPipelineState) +} +@(objc_type=IndirectCommandBufferDescriptor, objc_name="setMaxFragmentBufferBindCount") +IndirectCommandBufferDescriptor_setMaxFragmentBufferBindCount :: proc(self: ^IndirectCommandBufferDescriptor, maxFragmentBufferBindCount: NS.Integer) { + msgSend(nil, self, "setMaxFragmentBufferBindCount:", maxFragmentBufferBindCount) +} +@(objc_type=IndirectCommandBufferDescriptor, objc_name="setMaxKernelBufferBindCount") +IndirectCommandBufferDescriptor_setMaxKernelBufferBindCount :: proc(self: ^IndirectCommandBufferDescriptor, maxKernelBufferBindCount: NS.Integer) { + msgSend(nil, self, "setMaxKernelBufferBindCount:", maxKernelBufferBindCount) +} +@(objc_type=IndirectCommandBufferDescriptor, objc_name="setMaxVertexBufferBindCount") +IndirectCommandBufferDescriptor_setMaxVertexBufferBindCount :: proc(self: ^IndirectCommandBufferDescriptor, maxVertexBufferBindCount: NS.Integer) { + msgSend(nil, self, "setMaxVertexBufferBindCount:", maxVertexBufferBindCount) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + InstanceAccelerationStructureDescriptor +Class Methods: + alloc + descriptor +Methods: + init + instanceCount + instanceDescriptorBuffer + instanceDescriptorBufferOffset + instanceDescriptorStride + instancedAccelerationStructures + setInstanceCount + setInstanceDescriptorBuffer + setInstanceDescriptorBufferOffset + setInstanceDescriptorStride + setInstancedAccelerationStructures +*/ +@(objc_class="MTLInstanceAccelerationStructureDescriptor") +InstanceAccelerationStructureDescriptor :: struct { using _: NS.Copying(InstanceAccelerationStructureDescriptor) } + +@(objc_type=InstanceAccelerationStructureDescriptor, objc_class_name="alloc") +InstanceAccelerationStructureDescriptor_alloc :: proc() -> ^InstanceAccelerationStructureDescriptor { + return msgSend(^InstanceAccelerationStructureDescriptor, InstanceAccelerationStructureDescriptor, "alloc") +} +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="init") +InstanceAccelerationStructureDescriptor_init :: proc(self: ^InstanceAccelerationStructureDescriptor) -> ^InstanceAccelerationStructureDescriptor { + return msgSend(^InstanceAccelerationStructureDescriptor, self, "init") +} +@(objc_type=InstanceAccelerationStructureDescriptor, objc_class_name="descriptor") +InstanceAccelerationStructureDescriptor_descriptor :: proc() -> ^InstanceAccelerationStructureDescriptor { + return msgSend(^InstanceAccelerationStructureDescriptor, InstanceAccelerationStructureDescriptor, "descriptor") +} +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceCount") +InstanceAccelerationStructureDescriptor_instanceCount :: proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "instanceCount") +} +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceDescriptorBuffer") +InstanceAccelerationStructureDescriptor_instanceDescriptorBuffer :: proc(self: ^InstanceAccelerationStructureDescriptor) -> ^InstanceAccelerationStructureDescriptor { + return msgSend(^InstanceAccelerationStructureDescriptor, self, "instanceDescriptorBuffer") +} +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceDescriptorBufferOffset") +InstanceAccelerationStructureDescriptor_instanceDescriptorBufferOffset :: proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "instanceDescriptorBufferOffset") +} +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceDescriptorStride") +InstanceAccelerationStructureDescriptor_instanceDescriptorStride :: proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "instanceDescriptorStride") +} +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instancedAccelerationStructures") +InstanceAccelerationStructureDescriptor_instancedAccelerationStructures :: proc(self: ^InstanceAccelerationStructureDescriptor) -> ^NS.Array { + return msgSend(^NS.Array, self, "instancedAccelerationStructures") +} +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceCount") +InstanceAccelerationStructureDescriptor_setInstanceCount :: proc(self: ^InstanceAccelerationStructureDescriptor, instanceCount: NS.Integer) { + msgSend(nil, self, "setInstanceCount:", instanceCount) +} +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceDescriptorBuffer") +InstanceAccelerationStructureDescriptor_setInstanceDescriptorBuffer :: proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorBuffer: ^NS.Object) { + msgSend(nil, self, "setInstanceDescriptorBuffer:", instanceDescriptorBuffer) +} +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceDescriptorBufferOffset") +InstanceAccelerationStructureDescriptor_setInstanceDescriptorBufferOffset :: proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorBufferOffset: NS.Integer) { + msgSend(nil, self, "setInstanceDescriptorBufferOffset:", instanceDescriptorBufferOffset) +} +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceDescriptorStride") +InstanceAccelerationStructureDescriptor_setInstanceDescriptorStride :: proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorStride: NS.Integer) { + msgSend(nil, self, "setInstanceDescriptorStride:", instanceDescriptorStride) +} +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstancedAccelerationStructures") +InstanceAccelerationStructureDescriptor_setInstancedAccelerationStructures :: proc(self: ^InstanceAccelerationStructureDescriptor, instancedAccelerationStructures: ^NS.Array) { + msgSend(nil, self, "setInstancedAccelerationStructures:", instancedAccelerationStructures) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + IntersectionFunctionTableDescriptor +Class Methods: + alloc + intersectionFunctionTableDescriptor +Methods: + init + functionCount + setFunctionCount +*/ +@(objc_class="MTLIntersectionFunctionTableDescriptor") +IntersectionFunctionTableDescriptor :: struct { using _: NS.Copying(IntersectionFunctionTableDescriptor) } + +@(objc_type=IntersectionFunctionTableDescriptor, objc_class_name="alloc") +IntersectionFunctionTableDescriptor_alloc :: proc() -> ^IntersectionFunctionTableDescriptor { + return msgSend(^IntersectionFunctionTableDescriptor, IntersectionFunctionTableDescriptor, "alloc") +} +@(objc_type=IntersectionFunctionTableDescriptor, objc_name="init") +IntersectionFunctionTableDescriptor_init :: proc(self: ^IntersectionFunctionTableDescriptor) -> ^IntersectionFunctionTableDescriptor { + return msgSend(^IntersectionFunctionTableDescriptor, self, "init") +} +@(objc_type=IntersectionFunctionTableDescriptor, objc_name="functionCount") +IntersectionFunctionTableDescriptor_functionCount :: proc(self: ^IntersectionFunctionTableDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "functionCount") +} +@(objc_type=IntersectionFunctionTableDescriptor, objc_class_name="intersectionFunctionTableDescriptor") +IntersectionFunctionTableDescriptor_intersectionFunctionTableDescriptor :: proc() -> ^IntersectionFunctionTableDescriptor { + return msgSend(^IntersectionFunctionTableDescriptor, IntersectionFunctionTableDescriptor, "intersectionFunctionTableDescriptor") +} +@(objc_type=IntersectionFunctionTableDescriptor, objc_name="setFunctionCount") +IntersectionFunctionTableDescriptor_setFunctionCount :: proc(self: ^IntersectionFunctionTableDescriptor, functionCount: NS.Integer) { + msgSend(nil, self, "setFunctionCount:", functionCount) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + LinkedFunctions +Class Methods: + alloc + linkedFunctions +Methods: + init + binaryFunctions + functions + groups + setBinaryFunctions + setFunctions + setGroups +*/ +@(objc_class="MTLLinkedFunctions") +LinkedFunctions :: struct { using _: NS.Copying(LinkedFunctions) } + +@(objc_type=LinkedFunctions, objc_class_name="alloc") +LinkedFunctions_alloc :: proc() -> ^LinkedFunctions { + return msgSend(^LinkedFunctions, LinkedFunctions, "alloc") +} +@(objc_type=LinkedFunctions, objc_name="init") +LinkedFunctions_init :: proc(self: ^LinkedFunctions) -> ^LinkedFunctions { + return msgSend(^LinkedFunctions, self, "init") +} +@(objc_type=LinkedFunctions, objc_name="binaryFunctions") +LinkedFunctions_binaryFunctions :: proc(self: ^LinkedFunctions) -> ^NS.Array { + return msgSend(^NS.Array, self, "binaryFunctions") +} +@(objc_type=LinkedFunctions, objc_name="functions") +LinkedFunctions_functions :: proc(self: ^LinkedFunctions) -> ^NS.Array { + return msgSend(^NS.Array, self, "functions") +} +@(objc_type=LinkedFunctions, objc_name="groups") +LinkedFunctions_groups :: proc(self: ^LinkedFunctions) -> ^NS.Dictionary { + return msgSend(^NS.Dictionary, self, "groups") +} +@(objc_type=LinkedFunctions, objc_class_name="linkedFunctions") +LinkedFunctions_linkedFunctions :: proc() -> ^LinkedFunctions { + return msgSend(^LinkedFunctions, LinkedFunctions, "linkedFunctions") +} +@(objc_type=LinkedFunctions, objc_name="setBinaryFunctions") +LinkedFunctions_setBinaryFunctions :: proc(self: ^LinkedFunctions, binaryFunctions: ^NS.Array) { + msgSend(nil, self, "setBinaryFunctions:", binaryFunctions) +} +@(objc_type=LinkedFunctions, objc_name="setFunctions") +LinkedFunctions_setFunctions :: proc(self: ^LinkedFunctions, functions: ^NS.Array) { + msgSend(nil, self, "setFunctions:", functions) +} +@(objc_type=LinkedFunctions, objc_name="setGroups") +LinkedFunctions_setGroups :: proc(self: ^LinkedFunctions, groups: ^NS.Dictionary) { + msgSend(nil, self, "setGroups:", groups) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + PipelineBufferDescriptor +Class Methods: + alloc +Methods: + init + mutability + setMutability +*/ +@(objc_class="MTLPipelineBufferDescriptor") +PipelineBufferDescriptor :: struct { using _: NS.Copying(PipelineBufferDescriptor) } + +@(objc_type=PipelineBufferDescriptor, objc_class_name="alloc") +PipelineBufferDescriptor_alloc :: proc() -> ^PipelineBufferDescriptor { + return msgSend(^PipelineBufferDescriptor, PipelineBufferDescriptor, "alloc") +} +@(objc_type=PipelineBufferDescriptor, objc_name="init") +PipelineBufferDescriptor_init :: proc(self: ^PipelineBufferDescriptor) -> ^PipelineBufferDescriptor { + return msgSend(^PipelineBufferDescriptor, self, "init") +} +@(objc_type=PipelineBufferDescriptor, objc_name="mutability") +PipelineBufferDescriptor_mutability :: proc(self: ^PipelineBufferDescriptor) -> Mutability { + return msgSend(Mutability, self, "mutability") +} +@(objc_type=PipelineBufferDescriptor, objc_name="setMutability") +PipelineBufferDescriptor_setMutability :: proc(self: ^PipelineBufferDescriptor, mutability: Mutability) { + msgSend(nil, self, "setMutability:", mutability) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + PipelineBufferDescriptorArray +Class Methods: + alloc +Methods: + init + objectAtIndexedSubscript + setObject +*/ +@(objc_class="MTLPipelineBufferDescriptorArray") +PipelineBufferDescriptorArray :: struct { using _: NS.Object } + +@(objc_type=PipelineBufferDescriptorArray, objc_class_name="alloc") +PipelineBufferDescriptorArray_alloc :: proc() -> ^PipelineBufferDescriptorArray { + return msgSend(^PipelineBufferDescriptorArray, PipelineBufferDescriptorArray, "alloc") +} +@(objc_type=PipelineBufferDescriptorArray, objc_name="init") +PipelineBufferDescriptorArray_init :: proc(self: ^PipelineBufferDescriptorArray) -> ^PipelineBufferDescriptorArray { + return msgSend(^PipelineBufferDescriptorArray, self, "init") +} +@(objc_type=PipelineBufferDescriptorArray, objc_name="objectAtIndexedSubscript") +PipelineBufferDescriptorArray_objectAtIndexedSubscript :: proc(self: ^PipelineBufferDescriptorArray, bufferIndex: ^NS.Object) -> ^PipelineBufferDescriptor { + return msgSend(^PipelineBufferDescriptor, self, "objectAtIndexedSubscript:", bufferIndex) +} +@(objc_type=PipelineBufferDescriptorArray, objc_name="setObject") +PipelineBufferDescriptorArray_setObject :: proc(self: ^PipelineBufferDescriptorArray, buffer: ^PipelineBufferDescriptor, bufferIndex: ^NS.Object) { + msgSend(nil, self, "setObject:atIndexedSubscript:", buffer, bufferIndex) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + PointerType +Class Methods: + alloc +Methods: + init + access + alignment + dataSize + elementArrayType + elementIsArgumentBuffer + elementStructType + elementType +*/ +@(objc_class="MTLPointerType") +PointerType :: struct { using _: NS.Object } + +@(objc_type=PointerType, objc_class_name="alloc") +PointerType_alloc :: proc() -> ^PointerType { + return msgSend(^PointerType, PointerType, "alloc") +} +@(objc_type=PointerType, objc_name="init") +PointerType_init :: proc(self: ^PointerType) -> ^PointerType { + return msgSend(^PointerType, self, "init") +} +@(objc_type=PointerType, objc_name="access") +PointerType_access :: proc(self: ^PointerType) -> ArgumentAccess { + return msgSend(ArgumentAccess, self, "access") +} +@(objc_type=PointerType, objc_name="alignment") +PointerType_alignment :: proc(self: ^PointerType) -> NS.Integer { + return msgSend(NS.Integer, self, "alignment") +} +@(objc_type=PointerType, objc_name="dataSize") +PointerType_dataSize :: proc(self: ^PointerType) -> NS.Integer { + return msgSend(NS.Integer, self, "dataSize") +} +@(objc_type=PointerType, objc_name="elementArrayType") +PointerType_elementArrayType :: proc(self: ^PointerType) -> ^ArrayType { + return msgSend(^ArrayType, self, "elementArrayType") +} +@(objc_type=PointerType, objc_name="elementIsArgumentBuffer") +PointerType_elementIsArgumentBuffer :: proc(self: ^PointerType) -> BOOL { + return msgSend(BOOL, self, "elementIsArgumentBuffer") +} +@(objc_type=PointerType, objc_name="elementStructType") +PointerType_elementStructType :: proc(self: ^PointerType) -> ^StructType { + return msgSend(^StructType, self, "elementStructType") +} +@(objc_type=PointerType, objc_name="elementType") +PointerType_elementType :: proc(self: ^PointerType) -> DataType { + return msgSend(DataType, self, "elementType") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + PrimitiveAccelerationStructureDescriptor +Class Methods: + alloc + descriptor +Methods: + init + geometryDescriptors + setGeometryDescriptors +*/ +@(objc_class="MTLPrimitiveAccelerationStructureDescriptor") +PrimitiveAccelerationStructureDescriptor :: struct { using _: NS.Copying(PrimitiveAccelerationStructureDescriptor) } + +@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_class_name="alloc") +PrimitiveAccelerationStructureDescriptor_alloc :: proc() -> ^PrimitiveAccelerationStructureDescriptor { + return msgSend(^PrimitiveAccelerationStructureDescriptor, PrimitiveAccelerationStructureDescriptor, "alloc") +} +@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="init") +PrimitiveAccelerationStructureDescriptor_init :: proc(self: ^PrimitiveAccelerationStructureDescriptor) -> ^PrimitiveAccelerationStructureDescriptor { + return msgSend(^PrimitiveAccelerationStructureDescriptor, self, "init") +} +@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_class_name="descriptor") +PrimitiveAccelerationStructureDescriptor_descriptor :: proc() -> ^PrimitiveAccelerationStructureDescriptor { + return msgSend(^PrimitiveAccelerationStructureDescriptor, PrimitiveAccelerationStructureDescriptor, "descriptor") +} +@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="geometryDescriptors") +PrimitiveAccelerationStructureDescriptor_geometryDescriptors :: proc(self: ^PrimitiveAccelerationStructureDescriptor) -> ^NS.Array { + return msgSend(^NS.Array, self, "geometryDescriptors") +} +@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="setGeometryDescriptors") +PrimitiveAccelerationStructureDescriptor_setGeometryDescriptors :: proc(self: ^PrimitiveAccelerationStructureDescriptor, geometryDescriptors: ^NS.Array) { + msgSend(nil, self, "setGeometryDescriptors:", geometryDescriptors) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + RasterizationRateLayerArray +Class Methods: + alloc +Methods: + init + objectAtIndexedSubscript + setObject +*/ +@(objc_class="MTLRasterizationRateLayerArray") +RasterizationRateLayerArray :: struct { using _: NS.Object } + +@(objc_type=RasterizationRateLayerArray, objc_class_name="alloc") +RasterizationRateLayerArray_alloc :: proc() -> ^RasterizationRateLayerArray { + return msgSend(^RasterizationRateLayerArray, RasterizationRateLayerArray, "alloc") +} +@(objc_type=RasterizationRateLayerArray, objc_name="init") +RasterizationRateLayerArray_init :: proc(self: ^RasterizationRateLayerArray) -> ^RasterizationRateLayerArray { + return msgSend(^RasterizationRateLayerArray, self, "init") +} +@(objc_type=RasterizationRateLayerArray, objc_name="objectAtIndexedSubscript") +RasterizationRateLayerArray_objectAtIndexedSubscript :: proc(self: ^RasterizationRateLayerArray, layerIndex: ^NS.Object) -> ^RasterizationRateLayerDescriptor { + return msgSend(^RasterizationRateLayerDescriptor, self, "objectAtIndexedSubscript:", layerIndex) +} +@(objc_type=RasterizationRateLayerArray, objc_name="setObject") +RasterizationRateLayerArray_setObject :: proc(self: ^RasterizationRateLayerArray, layer: ^RasterizationRateLayerDescriptor, layerIndex: ^NS.Object) { + msgSend(nil, self, "setObject:atIndexedSubscript:", layer, layerIndex) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + RasterizationRateLayerDescriptor +Class Methods: + alloc +Methods: + horizontal + horizontalSampleStorage + init + initWithSampleCount + initWithSampleCount + sampleCount + vertical + verticalSampleStorage +*/ +@(objc_class="MTLRasterizationRateLayerDescriptor") +RasterizationRateLayerDescriptor :: struct { using _: NS.Copying(RasterizationRateLayerDescriptor) } + +@(objc_type=RasterizationRateLayerDescriptor, objc_class_name="alloc") +RasterizationRateLayerDescriptor_alloc :: proc() -> ^RasterizationRateLayerDescriptor { + return msgSend(^RasterizationRateLayerDescriptor, RasterizationRateLayerDescriptor, "alloc") +} +@(objc_type=RasterizationRateLayerDescriptor, objc_name="horizontal") +RasterizationRateLayerDescriptor_horizontal :: proc(self: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateSampleArray { + return msgSend(^RasterizationRateSampleArray, self, "horizontal") +} +@(objc_type=RasterizationRateLayerDescriptor, objc_name="horizontalSampleStorage") +RasterizationRateLayerDescriptor_horizontalSampleStorage :: proc(self: ^RasterizationRateLayerDescriptor) -> ^f32 { + return msgSend(^f32, self, "horizontalSampleStorage") +} +@(objc_type=RasterizationRateLayerDescriptor, objc_name="init") +RasterizationRateLayerDescriptor_init :: proc(self: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateLayerDescriptor { + return msgSend(^RasterizationRateLayerDescriptor, self, "init") +} +@(objc_type=RasterizationRateLayerDescriptor, objc_name="initWithSampleCount") +RasterizationRateLayerDescriptor_initWithSampleCount :: proc(self: ^RasterizationRateLayerDescriptor, sampleCount: Size) -> ^RasterizationRateLayerDescriptor { + return msgSend(^RasterizationRateLayerDescriptor, self, "initWithSampleCount:", sampleCount) +} +@(objc_type=RasterizationRateLayerDescriptor, objc_name="initWithSampleCountWithDimensions") +RasterizationRateLayerDescriptor_initWithSampleCountWithDimensions :: proc(self: ^RasterizationRateLayerDescriptor, sampleCount: Size, horizontal: ^f32, vertical: ^f32) -> ^RasterizationRateLayerDescriptor { + return msgSend(^RasterizationRateLayerDescriptor, self, "initWithSampleCount:horizontal:vertical:", sampleCount, horizontal, vertical) +} +@(objc_type=RasterizationRateLayerDescriptor, objc_name="sampleCount") +RasterizationRateLayerDescriptor_sampleCount :: proc(self: ^RasterizationRateLayerDescriptor) -> Size { + return msgSend(Size, self, "sampleCount") +} +@(objc_type=RasterizationRateLayerDescriptor, objc_name="vertical") +RasterizationRateLayerDescriptor_vertical :: proc(self: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateSampleArray { + return msgSend(^RasterizationRateSampleArray, self, "vertical") +} +@(objc_type=RasterizationRateLayerDescriptor, objc_name="verticalSampleStorage") +RasterizationRateLayerDescriptor_verticalSampleStorage :: proc(self: ^RasterizationRateLayerDescriptor) -> ^f32 { + return msgSend(^f32, self, "verticalSampleStorage") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + RasterizationRateMapDescriptor +Class Methods: + alloc + rasterizationRateMapDescriptorWithScreenSize + rasterizationRateMapDescriptorWithScreenSize + rasterizationRateMapDescriptorWithScreenSize +Methods: + init + label + layerAtIndex + layerCount + layers + screenSize + setLabel + setLayer + setScreenSize +*/ +@(objc_class="MTLRasterizationRateMapDescriptor") +RasterizationRateMapDescriptor :: struct { using _: NS.Copying(RasterizationRateMapDescriptor) } + +@(objc_type=RasterizationRateMapDescriptor, objc_class_name="alloc") +RasterizationRateMapDescriptor_alloc :: proc() -> ^RasterizationRateMapDescriptor { + return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "alloc") +} +@(objc_type=RasterizationRateMapDescriptor, objc_name="init") +RasterizationRateMapDescriptor_init :: proc(self: ^RasterizationRateMapDescriptor) -> ^RasterizationRateMapDescriptor { + return msgSend(^RasterizationRateMapDescriptor, self, "init") +} +@(objc_type=RasterizationRateMapDescriptor, objc_name="label") +RasterizationRateMapDescriptor_label :: proc(self: ^RasterizationRateMapDescriptor) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=RasterizationRateMapDescriptor, objc_name="layerAtIndex") +RasterizationRateMapDescriptor_layerAtIndex :: proc(self: ^RasterizationRateMapDescriptor, layerIndex: ^NS.Object) -> ^RasterizationRateLayerDescriptor { + return msgSend(^RasterizationRateLayerDescriptor, self, "layerAtIndex:", layerIndex) +} +@(objc_type=RasterizationRateMapDescriptor, objc_name="layerCount") +RasterizationRateMapDescriptor_layerCount :: proc(self: ^RasterizationRateMapDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "layerCount") +} +@(objc_type=RasterizationRateMapDescriptor, objc_name="layers") +RasterizationRateMapDescriptor_layers :: proc(self: ^RasterizationRateMapDescriptor) -> ^RasterizationRateLayerArray { + return msgSend(^RasterizationRateLayerArray, self, "layers") +} +@(objc_type=RasterizationRateMapDescriptor, objc_class_name="rasterizationRateMapDescriptorWithScreenSize") +RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize :: proc(screenSize: Size) -> ^RasterizationRateMapDescriptor { + return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:", screenSize) +} +@(objc_type=RasterizationRateMapDescriptor, objc_class_name="rasterizationRateMapDescriptorWithScreenSize_layer_") +RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize_layer_ :: proc(screenSize: Size, layer: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateMapDescriptor { + return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:layer:", screenSize, layer) +} +@(objc_type=RasterizationRateMapDescriptor, objc_class_name="rasterizationRateMapDescriptorWithScreenSize_layerCount_layers_") +RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize_layerCount_layers_ :: proc(screenSize: Size, layerCount: ^NS.Object, layers: ^^RasterizationRateLayerDescriptor ) -> ^RasterizationRateMapDescriptor { + return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:layerCount:layers:", screenSize, layerCount, layers) +} +@(objc_type=RasterizationRateMapDescriptor, objc_name="screenSize") +RasterizationRateMapDescriptor_screenSize :: proc(self: ^RasterizationRateMapDescriptor) -> Size { + return msgSend(Size, self, "screenSize") +} +@(objc_type=RasterizationRateMapDescriptor, objc_name="setLabel") +RasterizationRateMapDescriptor_setLabel :: proc(self: ^RasterizationRateMapDescriptor, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} +@(objc_type=RasterizationRateMapDescriptor, objc_name="setLayer") +RasterizationRateMapDescriptor_setLayer :: proc(self: ^RasterizationRateMapDescriptor, layer: ^RasterizationRateLayerDescriptor, layerIndex: ^NS.Object) { + msgSend(nil, self, "setLayer:atIndex:", layer, layerIndex) +} +@(objc_type=RasterizationRateMapDescriptor, objc_name="setScreenSize") +RasterizationRateMapDescriptor_setScreenSize :: proc(self: ^RasterizationRateMapDescriptor, screenSize: Size) { + msgSend(nil, self, "setScreenSize:", screenSize) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + RasterizationRateSampleArray +Class Methods: + alloc +Methods: + init + objectAtIndexedSubscript + setObject +*/ +@(objc_class="MTLRasterizationRateSampleArray") +RasterizationRateSampleArray :: struct { using _: NS.Object } + +@(objc_type=RasterizationRateSampleArray, objc_class_name="alloc") +RasterizationRateSampleArray_alloc :: proc() -> ^RasterizationRateSampleArray { + return msgSend(^RasterizationRateSampleArray, RasterizationRateSampleArray, "alloc") +} +@(objc_type=RasterizationRateSampleArray, objc_name="init") +RasterizationRateSampleArray_init :: proc(self: ^RasterizationRateSampleArray) -> ^RasterizationRateSampleArray { + return msgSend(^RasterizationRateSampleArray, self, "init") +} +@(objc_type=RasterizationRateSampleArray, objc_name="objectAtIndexedSubscript") +RasterizationRateSampleArray_objectAtIndexedSubscript :: proc(self: ^RasterizationRateSampleArray, index: ^NS.Object) -> ^NS.Number { + return msgSend(^NS.Number, self, "objectAtIndexedSubscript:", index) +} +@(objc_type=RasterizationRateSampleArray, objc_name="setObject") +RasterizationRateSampleArray_setObject :: proc(self: ^RasterizationRateSampleArray, value: ^NS.Number, index: ^NS.Object) { + msgSend(nil, self, "setObject:atIndexedSubscript:", value, index) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + RenderPassAttachmentDescriptor +Class Methods: + alloc +Methods: + init + depthPlane + level + loadAction + resolveDepthPlane + resolveLevel + resolveSlice + resolveTexture + setDepthPlane + setLevel + setLoadAction + setResolveDepthPlane + setResolveLevel + setResolveSlice + setResolveTexture + setSlice + setStoreAction + setStoreActionOptions + setTexture + slice + storeAction + storeActionOptions + texture +*/ +@(objc_class="MTLRenderPassAttachmentDescriptor") +RenderPassAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassAttachmentDescriptor) } + +@(objc_type=RenderPassAttachmentDescriptor, objc_class_name="alloc") +RenderPassAttachmentDescriptor_alloc :: proc() -> ^RenderPassAttachmentDescriptor { + return msgSend(^RenderPassAttachmentDescriptor, RenderPassAttachmentDescriptor, "alloc") +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="init") +RenderPassAttachmentDescriptor_init :: proc(self: ^RenderPassAttachmentDescriptor) -> ^RenderPassAttachmentDescriptor { + return msgSend(^RenderPassAttachmentDescriptor, self, "init") +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="depthPlane") +RenderPassAttachmentDescriptor_depthPlane :: proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "depthPlane") +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="level") +RenderPassAttachmentDescriptor_level :: proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "level") +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="loadAction") +RenderPassAttachmentDescriptor_loadAction :: proc(self: ^RenderPassAttachmentDescriptor) -> LoadAction { + return msgSend(LoadAction, self, "loadAction") +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveDepthPlane") +RenderPassAttachmentDescriptor_resolveDepthPlane :: proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "resolveDepthPlane") +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveLevel") +RenderPassAttachmentDescriptor_resolveLevel :: proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "resolveLevel") +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveSlice") +RenderPassAttachmentDescriptor_resolveSlice :: proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "resolveSlice") +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveTexture") +RenderPassAttachmentDescriptor_resolveTexture :: proc(self: ^RenderPassAttachmentDescriptor) -> ^RenderPassAttachmentDescriptor { + return msgSend(^RenderPassAttachmentDescriptor, self, "resolveTexture") +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="setDepthPlane") +RenderPassAttachmentDescriptor_setDepthPlane :: proc(self: ^RenderPassAttachmentDescriptor, depthPlane: NS.Integer) { + msgSend(nil, self, "setDepthPlane:", depthPlane) +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="setLevel") +RenderPassAttachmentDescriptor_setLevel :: proc(self: ^RenderPassAttachmentDescriptor, level: NS.Integer) { + msgSend(nil, self, "setLevel:", level) +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="setLoadAction") +RenderPassAttachmentDescriptor_setLoadAction :: proc(self: ^RenderPassAttachmentDescriptor, loadAction: LoadAction) { + msgSend(nil, self, "setLoadAction:", loadAction) +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveDepthPlane") +RenderPassAttachmentDescriptor_setResolveDepthPlane :: proc(self: ^RenderPassAttachmentDescriptor, resolveDepthPlane: NS.Integer) { + msgSend(nil, self, "setResolveDepthPlane:", resolveDepthPlane) +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveLevel") +RenderPassAttachmentDescriptor_setResolveLevel :: proc(self: ^RenderPassAttachmentDescriptor, resolveLevel: NS.Integer) { + msgSend(nil, self, "setResolveLevel:", resolveLevel) +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveSlice") +RenderPassAttachmentDescriptor_setResolveSlice :: proc(self: ^RenderPassAttachmentDescriptor, resolveSlice: NS.Integer) { + msgSend(nil, self, "setResolveSlice:", resolveSlice) +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveTexture") +RenderPassAttachmentDescriptor_setResolveTexture :: proc(self: ^RenderPassAttachmentDescriptor, resolveTexture: ^NS.Object) { + msgSend(nil, self, "setResolveTexture:", resolveTexture) +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="setSlice") +RenderPassAttachmentDescriptor_setSlice :: proc(self: ^RenderPassAttachmentDescriptor, slice: NS.Integer) { + msgSend(nil, self, "setSlice:", slice) +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="setStoreAction") +RenderPassAttachmentDescriptor_setStoreAction :: proc(self: ^RenderPassAttachmentDescriptor, storeAction: StoreAction) { + msgSend(nil, self, "setStoreAction:", storeAction) +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="setStoreActionOptions") +RenderPassAttachmentDescriptor_setStoreActionOptions :: proc(self: ^RenderPassAttachmentDescriptor, storeActionOptions: StoreActionOptions) { + msgSend(nil, self, "setStoreActionOptions:", storeActionOptions) +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="setTexture") +RenderPassAttachmentDescriptor_setTexture :: proc(self: ^RenderPassAttachmentDescriptor, texture: ^NS.Object) { + msgSend(nil, self, "setTexture:", texture) +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="slice") +RenderPassAttachmentDescriptor_slice :: proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "slice") +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="storeAction") +RenderPassAttachmentDescriptor_storeAction :: proc(self: ^RenderPassAttachmentDescriptor) -> StoreAction { + return msgSend(StoreAction, self, "storeAction") +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="storeActionOptions") +RenderPassAttachmentDescriptor_storeActionOptions :: proc(self: ^RenderPassAttachmentDescriptor) -> StoreActionOptions { + return msgSend(StoreActionOptions, self, "storeActionOptions") +} +@(objc_type=RenderPassAttachmentDescriptor, objc_name="texture") +RenderPassAttachmentDescriptor_texture :: proc(self: ^RenderPassAttachmentDescriptor) -> ^RenderPassAttachmentDescriptor { + return msgSend(^RenderPassAttachmentDescriptor, self, "texture") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + RenderPassColorAttachmentDescriptor +Class Methods: + alloc +Methods: + init + clearColor + setClearColor +*/ +@(objc_class="MTLRenderPassColorAttachmentDescriptor") +RenderPassColorAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassColorAttachmentDescriptor) } + +@(objc_type=RenderPassColorAttachmentDescriptor, objc_class_name="alloc") +RenderPassColorAttachmentDescriptor_alloc :: proc() -> ^RenderPassColorAttachmentDescriptor { + return msgSend(^RenderPassColorAttachmentDescriptor, RenderPassColorAttachmentDescriptor, "alloc") +} +@(objc_type=RenderPassColorAttachmentDescriptor, objc_name="init") +RenderPassColorAttachmentDescriptor_init :: proc(self: ^RenderPassColorAttachmentDescriptor) -> ^RenderPassColorAttachmentDescriptor { + return msgSend(^RenderPassColorAttachmentDescriptor, self, "init") +} +@(objc_type=RenderPassColorAttachmentDescriptor, objc_name="clearColor") +RenderPassColorAttachmentDescriptor_clearColor :: proc(self: ^RenderPassColorAttachmentDescriptor) -> ClearColor { + return msgSend(ClearColor, self, "clearColor") +} +@(objc_type=RenderPassColorAttachmentDescriptor, objc_name="setClearColor") +RenderPassColorAttachmentDescriptor_setClearColor :: proc(self: ^RenderPassColorAttachmentDescriptor, clearColor: ClearColor) { + msgSend(nil, self, "setClearColor:", clearColor) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + RenderPassColorAttachmentDescriptorArray +Class Methods: + alloc +Methods: + init + objectAtIndexedSubscript + setObject +*/ +@(objc_class="MTLRenderPassColorAttachmentDescriptorArray") +RenderPassColorAttachmentDescriptorArray :: struct { using _: NS.Object } + +@(objc_type=RenderPassColorAttachmentDescriptorArray, objc_class_name="alloc") +RenderPassColorAttachmentDescriptorArray_alloc :: proc() -> ^RenderPassColorAttachmentDescriptorArray { + return msgSend(^RenderPassColorAttachmentDescriptorArray, RenderPassColorAttachmentDescriptorArray, "alloc") +} +@(objc_type=RenderPassColorAttachmentDescriptorArray, objc_name="init") +RenderPassColorAttachmentDescriptorArray_init :: proc(self: ^RenderPassColorAttachmentDescriptorArray) -> ^RenderPassColorAttachmentDescriptorArray { + return msgSend(^RenderPassColorAttachmentDescriptorArray, self, "init") +} +@(objc_type=RenderPassColorAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") +RenderPassColorAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^RenderPassColorAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^RenderPassColorAttachmentDescriptor { + return msgSend(^RenderPassColorAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) +} +@(objc_type=RenderPassColorAttachmentDescriptorArray, objc_name="setObject") +RenderPassColorAttachmentDescriptorArray_setObject :: proc(self: ^RenderPassColorAttachmentDescriptorArray, attachment: ^RenderPassColorAttachmentDescriptor, attachmentIndex: ^NS.Object) { + msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + RenderPassDepthAttachmentDescriptor +Class Methods: + alloc +Methods: + init + clearDepth + depthResolveFilter + setClearDepth + setDepthResolveFilter +*/ +@(objc_class="MTLRenderPassDepthAttachmentDescriptor") +RenderPassDepthAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassDepthAttachmentDescriptor) } + +@(objc_type=RenderPassDepthAttachmentDescriptor, objc_class_name="alloc") +RenderPassDepthAttachmentDescriptor_alloc :: proc() -> ^RenderPassDepthAttachmentDescriptor { + return msgSend(^RenderPassDepthAttachmentDescriptor, RenderPassDepthAttachmentDescriptor, "alloc") +} +@(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="init") +RenderPassDepthAttachmentDescriptor_init :: proc(self: ^RenderPassDepthAttachmentDescriptor) -> ^RenderPassDepthAttachmentDescriptor { + return msgSend(^RenderPassDepthAttachmentDescriptor, self, "init") +} +@(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="clearDepth") +RenderPassDepthAttachmentDescriptor_clearDepth :: proc(self: ^RenderPassDepthAttachmentDescriptor) -> f64 { + return msgSend(f64, self, "clearDepth") +} +@(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="depthResolveFilter") +RenderPassDepthAttachmentDescriptor_depthResolveFilter :: proc(self: ^RenderPassDepthAttachmentDescriptor) -> MultisampleDepthResolveFilter { + return msgSend(MultisampleDepthResolveFilter, self, "depthResolveFilter") +} +@(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="setClearDepth") +RenderPassDepthAttachmentDescriptor_setClearDepth :: proc(self: ^RenderPassDepthAttachmentDescriptor, clearDepth: f64) { + msgSend(nil, self, "setClearDepth:", clearDepth) +} +@(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="setDepthResolveFilter") +RenderPassDepthAttachmentDescriptor_setDepthResolveFilter :: proc(self: ^RenderPassDepthAttachmentDescriptor, depthResolveFilter: MultisampleDepthResolveFilter) { + msgSend(nil, self, "setDepthResolveFilter:", depthResolveFilter) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + RenderPassDescriptor +Class Methods: + alloc + renderPassDescriptor +Methods: + init + colorAttachments + defaultRasterSampleCount + depthAttachment + getSamplePositions + imageblockSampleLength + rasterizationRateMap + renderTargetArrayLength + renderTargetHeight + renderTargetWidth + sampleBufferAttachments + setDefaultRasterSampleCount + setDepthAttachment + setImageblockSampleLength + setRasterizationRateMap + setRenderTargetArrayLength + setRenderTargetHeight + setRenderTargetWidth + setSamplePositions + setStencilAttachment + setThreadgroupMemoryLength + setTileHeight + setTileWidth + setVisibilityResultBuffer + stencilAttachment + threadgroupMemoryLength + tileHeight + tileWidth + visibilityResultBuffer +*/ +@(objc_class="MTLRenderPassDescriptor") +RenderPassDescriptor :: struct { using _: NS.Copying(RenderPassDescriptor) } + +@(objc_type=RenderPassDescriptor, objc_class_name="alloc") +RenderPassDescriptor_alloc :: proc() -> ^RenderPassDescriptor { + return msgSend(^RenderPassDescriptor, RenderPassDescriptor, "alloc") +} +@(objc_type=RenderPassDescriptor, objc_name="init") +RenderPassDescriptor_init :: proc(self: ^RenderPassDescriptor) -> ^RenderPassDescriptor { + return msgSend(^RenderPassDescriptor, self, "init") +} +@(objc_type=RenderPassDescriptor, objc_name="colorAttachments") +RenderPassDescriptor_colorAttachments :: proc(self: ^RenderPassDescriptor) -> ^RenderPassColorAttachmentDescriptorArray { + return msgSend(^RenderPassColorAttachmentDescriptorArray, self, "colorAttachments") +} +@(objc_type=RenderPassDescriptor, objc_name="defaultRasterSampleCount") +RenderPassDescriptor_defaultRasterSampleCount :: proc(self: ^RenderPassDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "defaultRasterSampleCount") +} +@(objc_type=RenderPassDescriptor, objc_name="depthAttachment") +RenderPassDescriptor_depthAttachment :: proc(self: ^RenderPassDescriptor) -> ^RenderPassDepthAttachmentDescriptor { + return msgSend(^RenderPassDepthAttachmentDescriptor, self, "depthAttachment") +} +@(objc_type=RenderPassDescriptor, objc_name="getSamplePositions") +RenderPassDescriptor_getSamplePositions :: proc(self: ^RenderPassDescriptor, positions: ^SamplePosition, count: ^NS.Object) -> ^RenderPassDescriptor { + return msgSend(^RenderPassDescriptor, self, "getSamplePositions:count:", positions, count) +} +@(objc_type=RenderPassDescriptor, objc_name="imageblockSampleLength") +RenderPassDescriptor_imageblockSampleLength :: proc(self: ^RenderPassDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "imageblockSampleLength") +} +@(objc_type=RenderPassDescriptor, objc_name="rasterizationRateMap") +RenderPassDescriptor_rasterizationRateMap :: proc(self: ^RenderPassDescriptor) -> ^RenderPassDescriptor { + return msgSend(^RenderPassDescriptor, self, "rasterizationRateMap") +} +@(objc_type=RenderPassDescriptor, objc_class_name="renderPassDescriptor") +RenderPassDescriptor_renderPassDescriptor :: proc() -> ^RenderPassDescriptor { + return msgSend(^RenderPassDescriptor, RenderPassDescriptor, "renderPassDescriptor") +} +@(objc_type=RenderPassDescriptor, objc_name="renderTargetArrayLength") +RenderPassDescriptor_renderTargetArrayLength :: proc(self: ^RenderPassDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "renderTargetArrayLength") +} +@(objc_type=RenderPassDescriptor, objc_name="renderTargetHeight") +RenderPassDescriptor_renderTargetHeight :: proc(self: ^RenderPassDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "renderTargetHeight") +} +@(objc_type=RenderPassDescriptor, objc_name="renderTargetWidth") +RenderPassDescriptor_renderTargetWidth :: proc(self: ^RenderPassDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "renderTargetWidth") +} +@(objc_type=RenderPassDescriptor, objc_name="sampleBufferAttachments") +RenderPassDescriptor_sampleBufferAttachments :: proc(self: ^RenderPassDescriptor) -> ^RenderPassSampleBufferAttachmentDescriptorArray { + return msgSend(^RenderPassSampleBufferAttachmentDescriptorArray, self, "sampleBufferAttachments") +} +@(objc_type=RenderPassDescriptor, objc_name="setDefaultRasterSampleCount") +RenderPassDescriptor_setDefaultRasterSampleCount :: proc(self: ^RenderPassDescriptor, defaultRasterSampleCount: NS.Integer) { + msgSend(nil, self, "setDefaultRasterSampleCount:", defaultRasterSampleCount) +} +@(objc_type=RenderPassDescriptor, objc_name="setDepthAttachment") +RenderPassDescriptor_setDepthAttachment :: proc(self: ^RenderPassDescriptor, depthAttachment: ^RenderPassDepthAttachmentDescriptor) { + msgSend(nil, self, "setDepthAttachment:", depthAttachment) +} +@(objc_type=RenderPassDescriptor, objc_name="setImageblockSampleLength") +RenderPassDescriptor_setImageblockSampleLength :: proc(self: ^RenderPassDescriptor, imageblockSampleLength: NS.Integer) { + msgSend(nil, self, "setImageblockSampleLength:", imageblockSampleLength) +} +@(objc_type=RenderPassDescriptor, objc_name="setRasterizationRateMap") +RenderPassDescriptor_setRasterizationRateMap :: proc(self: ^RenderPassDescriptor, rasterizationRateMap: ^NS.Object) { + msgSend(nil, self, "setRasterizationRateMap:", rasterizationRateMap) +} +@(objc_type=RenderPassDescriptor, objc_name="setRenderTargetArrayLength") +RenderPassDescriptor_setRenderTargetArrayLength :: proc(self: ^RenderPassDescriptor, renderTargetArrayLength: NS.Integer) { + msgSend(nil, self, "setRenderTargetArrayLength:", renderTargetArrayLength) +} +@(objc_type=RenderPassDescriptor, objc_name="setRenderTargetHeight") +RenderPassDescriptor_setRenderTargetHeight :: proc(self: ^RenderPassDescriptor, renderTargetHeight: NS.Integer) { + msgSend(nil, self, "setRenderTargetHeight:", renderTargetHeight) +} +@(objc_type=RenderPassDescriptor, objc_name="setRenderTargetWidth") +RenderPassDescriptor_setRenderTargetWidth :: proc(self: ^RenderPassDescriptor, renderTargetWidth: NS.Integer) { + msgSend(nil, self, "setRenderTargetWidth:", renderTargetWidth) +} +@(objc_type=RenderPassDescriptor, objc_name="setSamplePositions") +RenderPassDescriptor_setSamplePositions :: proc(self: ^RenderPassDescriptor, positions: ^SamplePosition, count: ^NS.Object) { + msgSend(nil, self, "setSamplePositions:count:", positions, count) +} +@(objc_type=RenderPassDescriptor, objc_name="setStencilAttachment") +RenderPassDescriptor_setStencilAttachment :: proc(self: ^RenderPassDescriptor, stencilAttachment: ^RenderPassStencilAttachmentDescriptor) { + msgSend(nil, self, "setStencilAttachment:", stencilAttachment) +} +@(objc_type=RenderPassDescriptor, objc_name="setThreadgroupMemoryLength") +RenderPassDescriptor_setThreadgroupMemoryLength :: proc(self: ^RenderPassDescriptor, threadgroupMemoryLength: NS.Integer) { + msgSend(nil, self, "setThreadgroupMemoryLength:", threadgroupMemoryLength) +} +@(objc_type=RenderPassDescriptor, objc_name="setTileHeight") +RenderPassDescriptor_setTileHeight :: proc(self: ^RenderPassDescriptor, tileHeight: NS.Integer) { + msgSend(nil, self, "setTileHeight:", tileHeight) +} +@(objc_type=RenderPassDescriptor, objc_name="setTileWidth") +RenderPassDescriptor_setTileWidth :: proc(self: ^RenderPassDescriptor, tileWidth: NS.Integer) { + msgSend(nil, self, "setTileWidth:", tileWidth) +} +@(objc_type=RenderPassDescriptor, objc_name="setVisibilityResultBuffer") +RenderPassDescriptor_setVisibilityResultBuffer :: proc(self: ^RenderPassDescriptor, visibilityResultBuffer: ^NS.Object) { + msgSend(nil, self, "setVisibilityResultBuffer:", visibilityResultBuffer) +} +@(objc_type=RenderPassDescriptor, objc_name="stencilAttachment") +RenderPassDescriptor_stencilAttachment :: proc(self: ^RenderPassDescriptor) -> ^RenderPassStencilAttachmentDescriptor { + return msgSend(^RenderPassStencilAttachmentDescriptor, self, "stencilAttachment") +} +@(objc_type=RenderPassDescriptor, objc_name="threadgroupMemoryLength") +RenderPassDescriptor_threadgroupMemoryLength :: proc(self: ^RenderPassDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "threadgroupMemoryLength") +} +@(objc_type=RenderPassDescriptor, objc_name="tileHeight") +RenderPassDescriptor_tileHeight :: proc(self: ^RenderPassDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "tileHeight") +} +@(objc_type=RenderPassDescriptor, objc_name="tileWidth") +RenderPassDescriptor_tileWidth :: proc(self: ^RenderPassDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "tileWidth") +} +@(objc_type=RenderPassDescriptor, objc_name="visibilityResultBuffer") +RenderPassDescriptor_visibilityResultBuffer :: proc(self: ^RenderPassDescriptor) -> ^RenderPassDescriptor { + return msgSend(^RenderPassDescriptor, self, "visibilityResultBuffer") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + RenderPassSampleBufferAttachmentDescriptor +Class Methods: + alloc +Methods: + init + endOfFragmentSampleIndex + endOfVertexSampleIndex + sampleBuffer + setEndOfFragmentSampleIndex + setEndOfVertexSampleIndex + setSampleBuffer + setStartOfFragmentSampleIndex + setStartOfVertexSampleIndex + startOfFragmentSampleIndex + startOfVertexSampleIndex +*/ +@(objc_class="MTLRenderPassSampleBufferAttachmentDescriptor") +RenderPassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassSampleBufferAttachmentDescriptor) } + +@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_class_name="alloc") +RenderPassSampleBufferAttachmentDescriptor_alloc :: proc() -> ^RenderPassSampleBufferAttachmentDescriptor { + return msgSend(^RenderPassSampleBufferAttachmentDescriptor, RenderPassSampleBufferAttachmentDescriptor, "alloc") +} +@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="init") +RenderPassSampleBufferAttachmentDescriptor_init :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> ^RenderPassSampleBufferAttachmentDescriptor { + return msgSend(^RenderPassSampleBufferAttachmentDescriptor, self, "init") +} +@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="endOfFragmentSampleIndex") +RenderPassSampleBufferAttachmentDescriptor_endOfFragmentSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "endOfFragmentSampleIndex") +} +@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="endOfVertexSampleIndex") +RenderPassSampleBufferAttachmentDescriptor_endOfVertexSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "endOfVertexSampleIndex") +} +@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") +RenderPassSampleBufferAttachmentDescriptor_sampleBuffer :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> ^RenderPassSampleBufferAttachmentDescriptor { + return msgSend(^RenderPassSampleBufferAttachmentDescriptor, self, "sampleBuffer") +} +@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setEndOfFragmentSampleIndex") +RenderPassSampleBufferAttachmentDescriptor_setEndOfFragmentSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor, endOfFragmentSampleIndex: NS.Integer) { + msgSend(nil, self, "setEndOfFragmentSampleIndex:", endOfFragmentSampleIndex) +} +@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setEndOfVertexSampleIndex") +RenderPassSampleBufferAttachmentDescriptor_setEndOfVertexSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor, endOfVertexSampleIndex: NS.Integer) { + msgSend(nil, self, "setEndOfVertexSampleIndex:", endOfVertexSampleIndex) +} +@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") +RenderPassSampleBufferAttachmentDescriptor_setSampleBuffer :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) { + msgSend(nil, self, "setSampleBuffer:", sampleBuffer) +} +@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setStartOfFragmentSampleIndex") +RenderPassSampleBufferAttachmentDescriptor_setStartOfFragmentSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor, startOfFragmentSampleIndex: NS.Integer) { + msgSend(nil, self, "setStartOfFragmentSampleIndex:", startOfFragmentSampleIndex) +} +@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setStartOfVertexSampleIndex") +RenderPassSampleBufferAttachmentDescriptor_setStartOfVertexSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor, startOfVertexSampleIndex: NS.Integer) { + msgSend(nil, self, "setStartOfVertexSampleIndex:", startOfVertexSampleIndex) +} +@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="startOfFragmentSampleIndex") +RenderPassSampleBufferAttachmentDescriptor_startOfFragmentSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "startOfFragmentSampleIndex") +} +@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="startOfVertexSampleIndex") +RenderPassSampleBufferAttachmentDescriptor_startOfVertexSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "startOfVertexSampleIndex") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + RenderPassSampleBufferAttachmentDescriptorArray +Class Methods: + alloc +Methods: + init + objectAtIndexedSubscript + setObject +*/ +@(objc_class="MTLRenderPassSampleBufferAttachmentDescriptorArray") +RenderPassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object } + +@(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_class_name="alloc") +RenderPassSampleBufferAttachmentDescriptorArray_alloc :: proc() -> ^RenderPassSampleBufferAttachmentDescriptorArray { + return msgSend(^RenderPassSampleBufferAttachmentDescriptorArray, RenderPassSampleBufferAttachmentDescriptorArray, "alloc") +} +@(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_name="init") +RenderPassSampleBufferAttachmentDescriptorArray_init :: proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray) -> ^RenderPassSampleBufferAttachmentDescriptorArray { + return msgSend(^RenderPassSampleBufferAttachmentDescriptorArray, self, "init") +} +@(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") +RenderPassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^RenderPassSampleBufferAttachmentDescriptor { + return msgSend(^RenderPassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) +} +@(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_name="setObject") +RenderPassSampleBufferAttachmentDescriptorArray_setObject :: proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray, attachment: ^RenderPassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) { + msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + RenderPassStencilAttachmentDescriptor +Class Methods: + alloc +Methods: + init + clearStencil + setClearStencil + setStencilResolveFilter + stencilResolveFilter +*/ +@(objc_class="MTLRenderPassStencilAttachmentDescriptor") +RenderPassStencilAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassStencilAttachmentDescriptor) } + +@(objc_type=RenderPassStencilAttachmentDescriptor, objc_class_name="alloc") +RenderPassStencilAttachmentDescriptor_alloc :: proc() -> ^RenderPassStencilAttachmentDescriptor { + return msgSend(^RenderPassStencilAttachmentDescriptor, RenderPassStencilAttachmentDescriptor, "alloc") +} +@(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="init") +RenderPassStencilAttachmentDescriptor_init :: proc(self: ^RenderPassStencilAttachmentDescriptor) -> ^RenderPassStencilAttachmentDescriptor { + return msgSend(^RenderPassStencilAttachmentDescriptor, self, "init") +} +@(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="clearStencil") +RenderPassStencilAttachmentDescriptor_clearStencil :: proc(self: ^RenderPassStencilAttachmentDescriptor) -> u32 { + return msgSend(u32, self, "clearStencil") +} +@(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="setClearStencil") +RenderPassStencilAttachmentDescriptor_setClearStencil :: proc(self: ^RenderPassStencilAttachmentDescriptor, clearStencil: u32) { + msgSend(nil, self, "setClearStencil:", clearStencil) +} +@(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="setStencilResolveFilter") +RenderPassStencilAttachmentDescriptor_setStencilResolveFilter :: proc(self: ^RenderPassStencilAttachmentDescriptor, stencilResolveFilter: MultisampleStencilResolveFilter) { + msgSend(nil, self, "setStencilResolveFilter:", stencilResolveFilter) +} +@(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="stencilResolveFilter") +RenderPassStencilAttachmentDescriptor_stencilResolveFilter :: proc(self: ^RenderPassStencilAttachmentDescriptor) -> MultisampleStencilResolveFilter { + return msgSend(MultisampleStencilResolveFilter, self, "stencilResolveFilter") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + RenderPipelineColorAttachmentDescriptor +Class Methods: + alloc +Methods: + init + alphaBlendOperation + destinationAlphaBlendFactor + destinationRGBBlendFactor + isBlendingEnabled + pixelFormat + rgbBlendOperation + setAlphaBlendOperation + setBlendingEnabled + setDestinationAlphaBlendFactor + setDestinationRGBBlendFactor + setPixelFormat + setRgbBlendOperation + setSourceAlphaBlendFactor + setSourceRGBBlendFactor + setWriteMask + sourceAlphaBlendFactor + sourceRGBBlendFactor + writeMask +*/ +@(objc_class="MTLRenderPipelineColorAttachmentDescriptor") +RenderPipelineColorAttachmentDescriptor :: struct { using _: NS.Copying(RenderPipelineColorAttachmentDescriptor) } + +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_class_name="alloc") +RenderPipelineColorAttachmentDescriptor_alloc :: proc() -> ^RenderPipelineColorAttachmentDescriptor { + return msgSend(^RenderPipelineColorAttachmentDescriptor, RenderPipelineColorAttachmentDescriptor, "alloc") +} +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="init") +RenderPipelineColorAttachmentDescriptor_init :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> ^RenderPipelineColorAttachmentDescriptor { + return msgSend(^RenderPipelineColorAttachmentDescriptor, self, "init") +} +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="alphaBlendOperation") +RenderPipelineColorAttachmentDescriptor_alphaBlendOperation :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendOperation { + return msgSend(BlendOperation, self, "alphaBlendOperation") +} +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="destinationAlphaBlendFactor") +RenderPipelineColorAttachmentDescriptor_destinationAlphaBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { + return msgSend(BlendFactor, self, "destinationAlphaBlendFactor") +} +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="destinationRGBBlendFactor") +RenderPipelineColorAttachmentDescriptor_destinationRGBBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { + return msgSend(BlendFactor, self, "destinationRGBBlendFactor") +} +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="isBlendingEnabled") +RenderPipelineColorAttachmentDescriptor_isBlendingEnabled :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BOOL { + return msgSend(BOOL, self, "isBlendingEnabled") +} +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="pixelFormat") +RenderPipelineColorAttachmentDescriptor_pixelFormat :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> PixelFormat { + return msgSend(PixelFormat, self, "pixelFormat") +} +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="rgbBlendOperation") +RenderPipelineColorAttachmentDescriptor_rgbBlendOperation :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendOperation { + return msgSend(BlendOperation, self, "rgbBlendOperation") +} +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setAlphaBlendOperation") +RenderPipelineColorAttachmentDescriptor_setAlphaBlendOperation :: proc(self: ^RenderPipelineColorAttachmentDescriptor, alphaBlendOperation: BlendOperation) { + msgSend(nil, self, "setAlphaBlendOperation:", alphaBlendOperation) +} +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setBlendingEnabled") +RenderPipelineColorAttachmentDescriptor_setBlendingEnabled :: proc(self: ^RenderPipelineColorAttachmentDescriptor, blendingEnabled: BOOL) { + msgSend(nil, self, "setBlendingEnabled:", blendingEnabled) +} +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setDestinationAlphaBlendFactor") +RenderPipelineColorAttachmentDescriptor_setDestinationAlphaBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor, destinationAlphaBlendFactor: BlendFactor) { + msgSend(nil, self, "setDestinationAlphaBlendFactor:", destinationAlphaBlendFactor) +} +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setDestinationRGBBlendFactor") +RenderPipelineColorAttachmentDescriptor_setDestinationRGBBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor, destinationRGBBlendFactor: BlendFactor) { + msgSend(nil, self, "setDestinationRGBBlendFactor:", destinationRGBBlendFactor) +} +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setPixelFormat") +RenderPipelineColorAttachmentDescriptor_setPixelFormat :: proc(self: ^RenderPipelineColorAttachmentDescriptor, pixelFormat: PixelFormat) { + msgSend(nil, self, "setPixelFormat:", pixelFormat) +} +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setRgbBlendOperation") +RenderPipelineColorAttachmentDescriptor_setRgbBlendOperation :: proc(self: ^RenderPipelineColorAttachmentDescriptor, rgbBlendOperation: BlendOperation) { + msgSend(nil, self, "setRgbBlendOperation:", rgbBlendOperation) +} +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setSourceAlphaBlendFactor") +RenderPipelineColorAttachmentDescriptor_setSourceAlphaBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor, sourceAlphaBlendFactor: BlendFactor) { + msgSend(nil, self, "setSourceAlphaBlendFactor:", sourceAlphaBlendFactor) +} +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setSourceRGBBlendFactor") +RenderPipelineColorAttachmentDescriptor_setSourceRGBBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor, sourceRGBBlendFactor: BlendFactor) { + msgSend(nil, self, "setSourceRGBBlendFactor:", sourceRGBBlendFactor) +} +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setWriteMask") +RenderPipelineColorAttachmentDescriptor_setWriteMask :: proc(self: ^RenderPipelineColorAttachmentDescriptor, writeMask: ColorWriteMask) { + msgSend(nil, self, "setWriteMask:", writeMask) +} +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="sourceAlphaBlendFactor") +RenderPipelineColorAttachmentDescriptor_sourceAlphaBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { + return msgSend(BlendFactor, self, "sourceAlphaBlendFactor") +} +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="sourceRGBBlendFactor") +RenderPipelineColorAttachmentDescriptor_sourceRGBBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { + return msgSend(BlendFactor, self, "sourceRGBBlendFactor") +} +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="writeMask") +RenderPipelineColorAttachmentDescriptor_writeMask :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> ColorWriteMask { + return msgSend(ColorWriteMask, self, "writeMask") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + RenderPipelineColorAttachmentDescriptorArray +Class Methods: + alloc +Methods: + init + objectAtIndexedSubscript + setObject +*/ +@(objc_class="MTLRenderPipelineColorAttachmentDescriptorArray") +RenderPipelineColorAttachmentDescriptorArray :: struct { using _: NS.Object } + +@(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_class_name="alloc") +RenderPipelineColorAttachmentDescriptorArray_alloc :: proc() -> ^RenderPipelineColorAttachmentDescriptorArray { + return msgSend(^RenderPipelineColorAttachmentDescriptorArray, RenderPipelineColorAttachmentDescriptorArray, "alloc") +} +@(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_name="init") +RenderPipelineColorAttachmentDescriptorArray_init :: proc(self: ^RenderPipelineColorAttachmentDescriptorArray) -> ^RenderPipelineColorAttachmentDescriptorArray { + return msgSend(^RenderPipelineColorAttachmentDescriptorArray, self, "init") +} +@(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") +RenderPipelineColorAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^RenderPipelineColorAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^RenderPipelineColorAttachmentDescriptor { + return msgSend(^RenderPipelineColorAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) +} +@(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_name="setObject") +RenderPipelineColorAttachmentDescriptorArray_setObject :: proc(self: ^RenderPipelineColorAttachmentDescriptorArray, attachment: ^RenderPipelineColorAttachmentDescriptor, attachmentIndex: ^NS.Object) { + msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + RenderPipelineDescriptor +Class Methods: + alloc +Methods: + init + binaryArchives + colorAttachments + depthAttachmentPixelFormat + fragmentBuffers + fragmentFunction + inputPrimitiveTopology + isAlphaToCoverageEnabled + isAlphaToOneEnabled + isRasterizationEnabled + isTessellationFactorScaleEnabled + label + maxTessellationFactor + maxVertexAmplificationCount + rasterSampleCount + reset + sampleCount + setAlphaToCoverageEnabled + setAlphaToOneEnabled + setBinaryArchives + setDepthAttachmentPixelFormat + setFragmentFunction + setInputPrimitiveTopology + setLabel + setMaxTessellationFactor + setMaxVertexAmplificationCount + setRasterSampleCount + setRasterizationEnabled + setSampleCount + setStencilAttachmentPixelFormat + setSupportIndirectCommandBuffers + setTessellationControlPointIndexType + setTessellationFactorFormat + setTessellationFactorScaleEnabled + setTessellationFactorStepFunction + setTessellationOutputWindingOrder + setTessellationPartitionMode + setVertexDescriptor + setVertexFunction + stencilAttachmentPixelFormat + supportIndirectCommandBuffers + tessellationControlPointIndexType + tessellationFactorFormat + tessellationFactorStepFunction + tessellationOutputWindingOrder + tessellationPartitionMode + vertexBuffers + vertexDescriptor + vertexFunction +*/ +@(objc_class="MTLRenderPipelineDescriptor") +RenderPipelineDescriptor :: struct { using _: NS.Copying(RenderPipelineDescriptor) } + +@(objc_type=RenderPipelineDescriptor, objc_class_name="alloc") +RenderPipelineDescriptor_alloc :: proc() -> ^RenderPipelineDescriptor { + return msgSend(^RenderPipelineDescriptor, RenderPipelineDescriptor, "alloc") +} +@(objc_type=RenderPipelineDescriptor, objc_name="init") +RenderPipelineDescriptor_init :: proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineDescriptor { + return msgSend(^RenderPipelineDescriptor, self, "init") +} +@(objc_type=RenderPipelineDescriptor, objc_name="binaryArchives") +RenderPipelineDescriptor_binaryArchives :: proc(self: ^RenderPipelineDescriptor) -> ^NS.Array { + return msgSend(^NS.Array, self, "binaryArchives") +} +@(objc_type=RenderPipelineDescriptor, objc_name="colorAttachments") +RenderPipelineDescriptor_colorAttachments :: proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineColorAttachmentDescriptorArray { + return msgSend(^RenderPipelineColorAttachmentDescriptorArray, self, "colorAttachments") +} +@(objc_type=RenderPipelineDescriptor, objc_name="depthAttachmentPixelFormat") +RenderPipelineDescriptor_depthAttachmentPixelFormat :: proc(self: ^RenderPipelineDescriptor) -> PixelFormat { + return msgSend(PixelFormat, self, "depthAttachmentPixelFormat") +} +@(objc_type=RenderPipelineDescriptor, objc_name="fragmentBuffers") +RenderPipelineDescriptor_fragmentBuffers :: proc(self: ^RenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray { + return msgSend(^PipelineBufferDescriptorArray, self, "fragmentBuffers") +} +@(objc_type=RenderPipelineDescriptor, objc_name="fragmentFunction") +RenderPipelineDescriptor_fragmentFunction :: proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineDescriptor { + return msgSend(^RenderPipelineDescriptor, self, "fragmentFunction") +} +@(objc_type=RenderPipelineDescriptor, objc_name="inputPrimitiveTopology") +RenderPipelineDescriptor_inputPrimitiveTopology :: proc(self: ^RenderPipelineDescriptor) -> PrimitiveTopologyClass { + return msgSend(PrimitiveTopologyClass, self, "inputPrimitiveTopology") +} +@(objc_type=RenderPipelineDescriptor, objc_name="isAlphaToCoverageEnabled") +RenderPipelineDescriptor_isAlphaToCoverageEnabled :: proc(self: ^RenderPipelineDescriptor) -> BOOL { + return msgSend(BOOL, self, "isAlphaToCoverageEnabled") +} +@(objc_type=RenderPipelineDescriptor, objc_name="isAlphaToOneEnabled") +RenderPipelineDescriptor_isAlphaToOneEnabled :: proc(self: ^RenderPipelineDescriptor) -> BOOL { + return msgSend(BOOL, self, "isAlphaToOneEnabled") +} +@(objc_type=RenderPipelineDescriptor, objc_name="isRasterizationEnabled") +RenderPipelineDescriptor_isRasterizationEnabled :: proc(self: ^RenderPipelineDescriptor) -> BOOL { + return msgSend(BOOL, self, "isRasterizationEnabled") +} +@(objc_type=RenderPipelineDescriptor, objc_name="isTessellationFactorScaleEnabled") +RenderPipelineDescriptor_isTessellationFactorScaleEnabled :: proc(self: ^RenderPipelineDescriptor) -> BOOL { + return msgSend(BOOL, self, "isTessellationFactorScaleEnabled") +} +@(objc_type=RenderPipelineDescriptor, objc_name="label") +RenderPipelineDescriptor_label :: proc(self: ^RenderPipelineDescriptor) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=RenderPipelineDescriptor, objc_name="maxTessellationFactor") +RenderPipelineDescriptor_maxTessellationFactor :: proc(self: ^RenderPipelineDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "maxTessellationFactor") +} +@(objc_type=RenderPipelineDescriptor, objc_name="maxVertexAmplificationCount") +RenderPipelineDescriptor_maxVertexAmplificationCount :: proc(self: ^RenderPipelineDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "maxVertexAmplificationCount") +} +@(objc_type=RenderPipelineDescriptor, objc_name="rasterSampleCount") +RenderPipelineDescriptor_rasterSampleCount :: proc(self: ^RenderPipelineDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "rasterSampleCount") +} +@(objc_type=RenderPipelineDescriptor, objc_name="reset") +RenderPipelineDescriptor_reset :: proc(self: ^RenderPipelineDescriptor) { + msgSend(nil, self, "reset") +} +@(objc_type=RenderPipelineDescriptor, objc_name="sampleCount") +RenderPipelineDescriptor_sampleCount :: proc(self: ^RenderPipelineDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "sampleCount") +} +@(objc_type=RenderPipelineDescriptor, objc_name="setAlphaToCoverageEnabled") +RenderPipelineDescriptor_setAlphaToCoverageEnabled :: proc(self: ^RenderPipelineDescriptor, alphaToCoverageEnabled: BOOL) { + msgSend(nil, self, "setAlphaToCoverageEnabled:", alphaToCoverageEnabled) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setAlphaToOneEnabled") +RenderPipelineDescriptor_setAlphaToOneEnabled :: proc(self: ^RenderPipelineDescriptor, alphaToOneEnabled: BOOL) { + msgSend(nil, self, "setAlphaToOneEnabled:", alphaToOneEnabled) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setBinaryArchives") +RenderPipelineDescriptor_setBinaryArchives :: proc(self: ^RenderPipelineDescriptor, binaryArchives: ^NS.Array) { + msgSend(nil, self, "setBinaryArchives:", binaryArchives) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setDepthAttachmentPixelFormat") +RenderPipelineDescriptor_setDepthAttachmentPixelFormat :: proc(self: ^RenderPipelineDescriptor, depthAttachmentPixelFormat: PixelFormat) { + msgSend(nil, self, "setDepthAttachmentPixelFormat:", depthAttachmentPixelFormat) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setFragmentFunction") +RenderPipelineDescriptor_setFragmentFunction :: proc(self: ^RenderPipelineDescriptor, fragmentFunction: ^NS.Object) { + msgSend(nil, self, "setFragmentFunction:", fragmentFunction) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setInputPrimitiveTopology") +RenderPipelineDescriptor_setInputPrimitiveTopology :: proc(self: ^RenderPipelineDescriptor, inputPrimitiveTopology: PrimitiveTopologyClass) { + msgSend(nil, self, "setInputPrimitiveTopology:", inputPrimitiveTopology) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setLabel") +RenderPipelineDescriptor_setLabel :: proc(self: ^RenderPipelineDescriptor, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setMaxTessellationFactor") +RenderPipelineDescriptor_setMaxTessellationFactor :: proc(self: ^RenderPipelineDescriptor, maxTessellationFactor: NS.Integer) { + msgSend(nil, self, "setMaxTessellationFactor:", maxTessellationFactor) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setMaxVertexAmplificationCount") +RenderPipelineDescriptor_setMaxVertexAmplificationCount :: proc(self: ^RenderPipelineDescriptor, maxVertexAmplificationCount: NS.Integer) { + msgSend(nil, self, "setMaxVertexAmplificationCount:", maxVertexAmplificationCount) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setRasterSampleCount") +RenderPipelineDescriptor_setRasterSampleCount :: proc(self: ^RenderPipelineDescriptor, rasterSampleCount: NS.Integer) { + msgSend(nil, self, "setRasterSampleCount:", rasterSampleCount) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setRasterizationEnabled") +RenderPipelineDescriptor_setRasterizationEnabled :: proc(self: ^RenderPipelineDescriptor, rasterizationEnabled: BOOL) { + msgSend(nil, self, "setRasterizationEnabled:", rasterizationEnabled) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setSampleCount") +RenderPipelineDescriptor_setSampleCount :: proc(self: ^RenderPipelineDescriptor, sampleCount: NS.Integer) { + msgSend(nil, self, "setSampleCount:", sampleCount) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setStencilAttachmentPixelFormat") +RenderPipelineDescriptor_setStencilAttachmentPixelFormat :: proc(self: ^RenderPipelineDescriptor, stencilAttachmentPixelFormat: PixelFormat) { + msgSend(nil, self, "setStencilAttachmentPixelFormat:", stencilAttachmentPixelFormat) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setSupportIndirectCommandBuffers") +RenderPipelineDescriptor_setSupportIndirectCommandBuffers :: proc(self: ^RenderPipelineDescriptor, supportIndirectCommandBuffers: BOOL) { + msgSend(nil, self, "setSupportIndirectCommandBuffers:", supportIndirectCommandBuffers) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setTessellationControlPointIndexType") +RenderPipelineDescriptor_setTessellationControlPointIndexType :: proc(self: ^RenderPipelineDescriptor, tessellationControlPointIndexType: TessellationControlPointIndexType) { + msgSend(nil, self, "setTessellationControlPointIndexType:", tessellationControlPointIndexType) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setTessellationFactorFormat") +RenderPipelineDescriptor_setTessellationFactorFormat :: proc(self: ^RenderPipelineDescriptor, tessellationFactorFormat: TessellationFactorFormat) { + msgSend(nil, self, "setTessellationFactorFormat:", tessellationFactorFormat) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setTessellationFactorScaleEnabled") +RenderPipelineDescriptor_setTessellationFactorScaleEnabled :: proc(self: ^RenderPipelineDescriptor, tessellationFactorScaleEnabled: BOOL) { + msgSend(nil, self, "setTessellationFactorScaleEnabled:", tessellationFactorScaleEnabled) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setTessellationFactorStepFunction") +RenderPipelineDescriptor_setTessellationFactorStepFunction :: proc(self: ^RenderPipelineDescriptor, tessellationFactorStepFunction: TessellationFactorStepFunction) { + msgSend(nil, self, "setTessellationFactorStepFunction:", tessellationFactorStepFunction) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setTessellationOutputWindingOrder") +RenderPipelineDescriptor_setTessellationOutputWindingOrder :: proc(self: ^RenderPipelineDescriptor, tessellationOutputWindingOrder: Winding) { + msgSend(nil, self, "setTessellationOutputWindingOrder:", tessellationOutputWindingOrder) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setTessellationPartitionMode") +RenderPipelineDescriptor_setTessellationPartitionMode :: proc(self: ^RenderPipelineDescriptor, tessellationPartitionMode: TessellationPartitionMode) { + msgSend(nil, self, "setTessellationPartitionMode:", tessellationPartitionMode) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setVertexDescriptor") +RenderPipelineDescriptor_setVertexDescriptor :: proc(self: ^RenderPipelineDescriptor, vertexDescriptor: ^VertexDescriptor) { + msgSend(nil, self, "setVertexDescriptor:", vertexDescriptor) +} +@(objc_type=RenderPipelineDescriptor, objc_name="setVertexFunction") +RenderPipelineDescriptor_setVertexFunction :: proc(self: ^RenderPipelineDescriptor, vertexFunction: ^NS.Object) { + msgSend(nil, self, "setVertexFunction:", vertexFunction) +} +@(objc_type=RenderPipelineDescriptor, objc_name="stencilAttachmentPixelFormat") +RenderPipelineDescriptor_stencilAttachmentPixelFormat :: proc(self: ^RenderPipelineDescriptor) -> PixelFormat { + return msgSend(PixelFormat, self, "stencilAttachmentPixelFormat") +} +@(objc_type=RenderPipelineDescriptor, objc_name="supportIndirectCommandBuffers") +RenderPipelineDescriptor_supportIndirectCommandBuffers :: proc(self: ^RenderPipelineDescriptor) -> BOOL { + return msgSend(BOOL, self, "supportIndirectCommandBuffers") +} +@(objc_type=RenderPipelineDescriptor, objc_name="tessellationControlPointIndexType") +RenderPipelineDescriptor_tessellationControlPointIndexType :: proc(self: ^RenderPipelineDescriptor) -> TessellationControlPointIndexType { + return msgSend(TessellationControlPointIndexType, self, "tessellationControlPointIndexType") +} +@(objc_type=RenderPipelineDescriptor, objc_name="tessellationFactorFormat") +RenderPipelineDescriptor_tessellationFactorFormat :: proc(self: ^RenderPipelineDescriptor) -> TessellationFactorFormat { + return msgSend(TessellationFactorFormat, self, "tessellationFactorFormat") +} +@(objc_type=RenderPipelineDescriptor, objc_name="tessellationFactorStepFunction") +RenderPipelineDescriptor_tessellationFactorStepFunction :: proc(self: ^RenderPipelineDescriptor) -> TessellationFactorStepFunction { + return msgSend(TessellationFactorStepFunction, self, "tessellationFactorStepFunction") +} +@(objc_type=RenderPipelineDescriptor, objc_name="tessellationOutputWindingOrder") +RenderPipelineDescriptor_tessellationOutputWindingOrder :: proc(self: ^RenderPipelineDescriptor) -> Winding { + return msgSend(Winding, self, "tessellationOutputWindingOrder") +} +@(objc_type=RenderPipelineDescriptor, objc_name="tessellationPartitionMode") +RenderPipelineDescriptor_tessellationPartitionMode :: proc(self: ^RenderPipelineDescriptor) -> TessellationPartitionMode { + return msgSend(TessellationPartitionMode, self, "tessellationPartitionMode") +} +@(objc_type=RenderPipelineDescriptor, objc_name="vertexBuffers") +RenderPipelineDescriptor_vertexBuffers :: proc(self: ^RenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray { + return msgSend(^PipelineBufferDescriptorArray, self, "vertexBuffers") +} +@(objc_type=RenderPipelineDescriptor, objc_name="vertexDescriptor") +RenderPipelineDescriptor_vertexDescriptor :: proc(self: ^RenderPipelineDescriptor) -> ^VertexDescriptor { + return msgSend(^VertexDescriptor, self, "vertexDescriptor") +} +@(objc_type=RenderPipelineDescriptor, objc_name="vertexFunction") +RenderPipelineDescriptor_vertexFunction :: proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineDescriptor { + return msgSend(^RenderPipelineDescriptor, self, "vertexFunction") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + RenderPipelineReflection +Class Methods: + alloc +Methods: + init + fragmentArguments + tileArguments + vertexArguments +*/ +@(objc_class="MTLRenderPipelineReflection") +RenderPipelineReflection :: struct { using _: NS.Object } + +@(objc_type=RenderPipelineReflection, objc_class_name="alloc") +RenderPipelineReflection_alloc :: proc() -> ^RenderPipelineReflection { + return msgSend(^RenderPipelineReflection, RenderPipelineReflection, "alloc") +} +@(objc_type=RenderPipelineReflection, objc_name="init") +RenderPipelineReflection_init :: proc(self: ^RenderPipelineReflection) -> ^RenderPipelineReflection { + return msgSend(^RenderPipelineReflection, self, "init") +} +@(objc_type=RenderPipelineReflection, objc_name="fragmentArguments") +RenderPipelineReflection_fragmentArguments :: proc(self: ^RenderPipelineReflection) -> ^NS.Array { + return msgSend(^NS.Array, self, "fragmentArguments") +} +@(objc_type=RenderPipelineReflection, objc_name="tileArguments") +RenderPipelineReflection_tileArguments :: proc(self: ^RenderPipelineReflection) -> ^NS.Array { + return msgSend(^NS.Array, self, "tileArguments") +} +@(objc_type=RenderPipelineReflection, objc_name="vertexArguments") +RenderPipelineReflection_vertexArguments :: proc(self: ^RenderPipelineReflection) -> ^NS.Array { + return msgSend(^NS.Array, self, "vertexArguments") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + ResourceStatePassDescriptor +Class Methods: + alloc + resourceStatePassDescriptor +Methods: + init + sampleBufferAttachments +*/ +@(objc_class="MTLResourceStatePassDescriptor") +ResourceStatePassDescriptor :: struct { using _: NS.Copying(ResourceStatePassDescriptor) } + +@(objc_type=ResourceStatePassDescriptor, objc_class_name="alloc") +ResourceStatePassDescriptor_alloc :: proc() -> ^ResourceStatePassDescriptor { + return msgSend(^ResourceStatePassDescriptor, ResourceStatePassDescriptor, "alloc") +} +@(objc_type=ResourceStatePassDescriptor, objc_name="init") +ResourceStatePassDescriptor_init :: proc(self: ^ResourceStatePassDescriptor) -> ^ResourceStatePassDescriptor { + return msgSend(^ResourceStatePassDescriptor, self, "init") +} +@(objc_type=ResourceStatePassDescriptor, objc_class_name="resourceStatePassDescriptor") +ResourceStatePassDescriptor_resourceStatePassDescriptor :: proc() -> ^ResourceStatePassDescriptor { + return msgSend(^ResourceStatePassDescriptor, ResourceStatePassDescriptor, "resourceStatePassDescriptor") +} +@(objc_type=ResourceStatePassDescriptor, objc_name="sampleBufferAttachments") +ResourceStatePassDescriptor_sampleBufferAttachments :: proc(self: ^ResourceStatePassDescriptor) -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray { + return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptorArray, self, "sampleBufferAttachments") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + ResourceStatePassSampleBufferAttachmentDescriptor +Class Methods: + alloc +Methods: + init + endOfEncoderSampleIndex + sampleBuffer + setEndOfEncoderSampleIndex + setSampleBuffer + setStartOfEncoderSampleIndex + startOfEncoderSampleIndex +*/ +@(objc_class="MTLResourceStatePassSampleBufferAttachmentDescriptor") +ResourceStatePassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(ResourceStatePassSampleBufferAttachmentDescriptor) } + +@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_class_name="alloc") +ResourceStatePassSampleBufferAttachmentDescriptor_alloc :: proc() -> ^ResourceStatePassSampleBufferAttachmentDescriptor { + return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, ResourceStatePassSampleBufferAttachmentDescriptor, "alloc") +} +@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="init") +ResourceStatePassSampleBufferAttachmentDescriptor_init :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> ^ResourceStatePassSampleBufferAttachmentDescriptor { + return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, self, "init") +} +@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="endOfEncoderSampleIndex") +ResourceStatePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "endOfEncoderSampleIndex") +} +@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") +ResourceStatePassSampleBufferAttachmentDescriptor_sampleBuffer :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> ^ResourceStatePassSampleBufferAttachmentDescriptor { + return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, self, "sampleBuffer") +} +@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex") +ResourceStatePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.Integer) { + msgSend(nil, self, "setEndOfEncoderSampleIndex:", endOfEncoderSampleIndex) +} +@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") +ResourceStatePassSampleBufferAttachmentDescriptor_setSampleBuffer :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) { + msgSend(nil, self, "setSampleBuffer:", sampleBuffer) +} +@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="setStartOfEncoderSampleIndex") +ResourceStatePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.Integer) { + msgSend(nil, self, "setStartOfEncoderSampleIndex:", startOfEncoderSampleIndex) +} +@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="startOfEncoderSampleIndex") +ResourceStatePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "startOfEncoderSampleIndex") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + ResourceStatePassSampleBufferAttachmentDescriptorArray +Class Methods: + alloc +Methods: + init + objectAtIndexedSubscript + setObject +*/ +@(objc_class="MTLResourceStatePassSampleBufferAttachmentDescriptorArray") +ResourceStatePassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object } + +@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_class_name="alloc") +ResourceStatePassSampleBufferAttachmentDescriptorArray_alloc :: proc() -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray { + return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptorArray, ResourceStatePassSampleBufferAttachmentDescriptorArray, "alloc") +} +@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_name="init") +ResourceStatePassSampleBufferAttachmentDescriptorArray_init :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray) -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray { + return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptorArray, self, "init") +} +@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") +ResourceStatePassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^ResourceStatePassSampleBufferAttachmentDescriptor { + return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) +} +@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_name="setObject") +ResourceStatePassSampleBufferAttachmentDescriptorArray_setObject :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray, attachment: ^ResourceStatePassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) { + msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + SamplerDescriptor +Class Methods: + alloc +Methods: + init + borderColor + compareFunction + label + lodAverage + lodMaxClamp + lodMinClamp + magFilter + maxAnisotropy + minFilter + mipFilter + normalizedCoordinates + rAddressMode + sAddressMode + setBorderColor + setCompareFunction + setLabel + setLodAverage + setLodMaxClamp + setLodMinClamp + setMagFilter + setMaxAnisotropy + setMinFilter + setMipFilter + setNormalizedCoordinates + setRAddressMode + setSAddressMode + setSupportArgumentBuffers + setTAddressMode + supportArgumentBuffers + tAddressMode +*/ +@(objc_class="MTLSamplerDescriptor") +SamplerDescriptor :: struct { using _: NS.Copying(SamplerDescriptor) } + +@(objc_type=SamplerDescriptor, objc_class_name="alloc") +SamplerDescriptor_alloc :: proc() -> ^SamplerDescriptor { + return msgSend(^SamplerDescriptor, SamplerDescriptor, "alloc") +} +@(objc_type=SamplerDescriptor, objc_name="init") +SamplerDescriptor_init :: proc(self: ^SamplerDescriptor) -> ^SamplerDescriptor { + return msgSend(^SamplerDescriptor, self, "init") +} +@(objc_type=SamplerDescriptor, objc_name="borderColor") +SamplerDescriptor_borderColor :: proc(self: ^SamplerDescriptor) -> SamplerBorderColor { + return msgSend(SamplerBorderColor, self, "borderColor") +} +@(objc_type=SamplerDescriptor, objc_name="compareFunction") +SamplerDescriptor_compareFunction :: proc(self: ^SamplerDescriptor) -> CompareFunction { + return msgSend(CompareFunction, self, "compareFunction") +} +@(objc_type=SamplerDescriptor, objc_name="label") +SamplerDescriptor_label :: proc(self: ^SamplerDescriptor) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=SamplerDescriptor, objc_name="lodAverage") +SamplerDescriptor_lodAverage :: proc(self: ^SamplerDescriptor) -> BOOL { + return msgSend(BOOL, self, "lodAverage") +} +@(objc_type=SamplerDescriptor, objc_name="lodMaxClamp") +SamplerDescriptor_lodMaxClamp :: proc(self: ^SamplerDescriptor) -> f32 { + return msgSend(f32, self, "lodMaxClamp") +} +@(objc_type=SamplerDescriptor, objc_name="lodMinClamp") +SamplerDescriptor_lodMinClamp :: proc(self: ^SamplerDescriptor) -> f32 { + return msgSend(f32, self, "lodMinClamp") +} +@(objc_type=SamplerDescriptor, objc_name="magFilter") +SamplerDescriptor_magFilter :: proc(self: ^SamplerDescriptor) -> SamplerMinMagFilter { + return msgSend(SamplerMinMagFilter, self, "magFilter") +} +@(objc_type=SamplerDescriptor, objc_name="maxAnisotropy") +SamplerDescriptor_maxAnisotropy :: proc(self: ^SamplerDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "maxAnisotropy") +} +@(objc_type=SamplerDescriptor, objc_name="minFilter") +SamplerDescriptor_minFilter :: proc(self: ^SamplerDescriptor) -> SamplerMinMagFilter { + return msgSend(SamplerMinMagFilter, self, "minFilter") +} +@(objc_type=SamplerDescriptor, objc_name="mipFilter") +SamplerDescriptor_mipFilter :: proc(self: ^SamplerDescriptor) -> SamplerMipFilter { + return msgSend(SamplerMipFilter, self, "mipFilter") +} +@(objc_type=SamplerDescriptor, objc_name="normalizedCoordinates") +SamplerDescriptor_normalizedCoordinates :: proc(self: ^SamplerDescriptor) -> BOOL { + return msgSend(BOOL, self, "normalizedCoordinates") +} +@(objc_type=SamplerDescriptor, objc_name="rAddressMode") +SamplerDescriptor_rAddressMode :: proc(self: ^SamplerDescriptor) -> SamplerAddressMode { + return msgSend(SamplerAddressMode, self, "rAddressMode") +} +@(objc_type=SamplerDescriptor, objc_name="sAddressMode") +SamplerDescriptor_sAddressMode :: proc(self: ^SamplerDescriptor) -> SamplerAddressMode { + return msgSend(SamplerAddressMode, self, "sAddressMode") +} +@(objc_type=SamplerDescriptor, objc_name="setBorderColor") +SamplerDescriptor_setBorderColor :: proc(self: ^SamplerDescriptor, borderColor: SamplerBorderColor) { + msgSend(nil, self, "setBorderColor:", borderColor) +} +@(objc_type=SamplerDescriptor, objc_name="setCompareFunction") +SamplerDescriptor_setCompareFunction :: proc(self: ^SamplerDescriptor, compareFunction: CompareFunction) { + msgSend(nil, self, "setCompareFunction:", compareFunction) +} +@(objc_type=SamplerDescriptor, objc_name="setLabel") +SamplerDescriptor_setLabel :: proc(self: ^SamplerDescriptor, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} +@(objc_type=SamplerDescriptor, objc_name="setLodAverage") +SamplerDescriptor_setLodAverage :: proc(self: ^SamplerDescriptor, lodAverage: BOOL) { + msgSend(nil, self, "setLodAverage:", lodAverage) +} +@(objc_type=SamplerDescriptor, objc_name="setLodMaxClamp") +SamplerDescriptor_setLodMaxClamp :: proc(self: ^SamplerDescriptor, lodMaxClamp: f32) { + msgSend(nil, self, "setLodMaxClamp:", lodMaxClamp) +} +@(objc_type=SamplerDescriptor, objc_name="setLodMinClamp") +SamplerDescriptor_setLodMinClamp :: proc(self: ^SamplerDescriptor, lodMinClamp: f32) { + msgSend(nil, self, "setLodMinClamp:", lodMinClamp) +} +@(objc_type=SamplerDescriptor, objc_name="setMagFilter") +SamplerDescriptor_setMagFilter :: proc(self: ^SamplerDescriptor, magFilter: SamplerMinMagFilter) { + msgSend(nil, self, "setMagFilter:", magFilter) +} +@(objc_type=SamplerDescriptor, objc_name="setMaxAnisotropy") +SamplerDescriptor_setMaxAnisotropy :: proc(self: ^SamplerDescriptor, maxAnisotropy: NS.Integer) { + msgSend(nil, self, "setMaxAnisotropy:", maxAnisotropy) +} +@(objc_type=SamplerDescriptor, objc_name="setMinFilter") +SamplerDescriptor_setMinFilter :: proc(self: ^SamplerDescriptor, minFilter: SamplerMinMagFilter) { + msgSend(nil, self, "setMinFilter:", minFilter) +} +@(objc_type=SamplerDescriptor, objc_name="setMipFilter") +SamplerDescriptor_setMipFilter :: proc(self: ^SamplerDescriptor, mipFilter: SamplerMipFilter) { + msgSend(nil, self, "setMipFilter:", mipFilter) +} +@(objc_type=SamplerDescriptor, objc_name="setNormalizedCoordinates") +SamplerDescriptor_setNormalizedCoordinates :: proc(self: ^SamplerDescriptor, normalizedCoordinates: BOOL) { + msgSend(nil, self, "setNormalizedCoordinates:", normalizedCoordinates) +} +@(objc_type=SamplerDescriptor, objc_name="setRAddressMode") +SamplerDescriptor_setRAddressMode :: proc(self: ^SamplerDescriptor, rAddressMode: SamplerAddressMode) { + msgSend(nil, self, "setRAddressMode:", rAddressMode) +} +@(objc_type=SamplerDescriptor, objc_name="setSAddressMode") +SamplerDescriptor_setSAddressMode :: proc(self: ^SamplerDescriptor, sAddressMode: SamplerAddressMode) { + msgSend(nil, self, "setSAddressMode:", sAddressMode) +} +@(objc_type=SamplerDescriptor, objc_name="setSupportArgumentBuffers") +SamplerDescriptor_setSupportArgumentBuffers :: proc(self: ^SamplerDescriptor, supportArgumentBuffers: BOOL) { + msgSend(nil, self, "setSupportArgumentBuffers:", supportArgumentBuffers) +} +@(objc_type=SamplerDescriptor, objc_name="setTAddressMode") +SamplerDescriptor_setTAddressMode :: proc(self: ^SamplerDescriptor, tAddressMode: SamplerAddressMode) { + msgSend(nil, self, "setTAddressMode:", tAddressMode) +} +@(objc_type=SamplerDescriptor, objc_name="supportArgumentBuffers") +SamplerDescriptor_supportArgumentBuffers :: proc(self: ^SamplerDescriptor) -> BOOL { + return msgSend(BOOL, self, "supportArgumentBuffers") +} +@(objc_type=SamplerDescriptor, objc_name="tAddressMode") +SamplerDescriptor_tAddressMode :: proc(self: ^SamplerDescriptor) -> SamplerAddressMode { + return msgSend(SamplerAddressMode, self, "tAddressMode") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + SharedEventHandle +Class Methods: + alloc +Methods: + init + label +*/ +@(objc_class="MTLSharedEventHandle") +SharedEventHandle :: struct { using _: NS.Object } + +@(objc_type=SharedEventHandle, objc_class_name="alloc") +SharedEventHandle_alloc :: proc() -> ^SharedEventHandle { + return msgSend(^SharedEventHandle, SharedEventHandle, "alloc") +} +@(objc_type=SharedEventHandle, objc_name="init") +SharedEventHandle_init :: proc(self: ^SharedEventHandle) -> ^SharedEventHandle { + return msgSend(^SharedEventHandle, self, "init") +} +@(objc_type=SharedEventHandle, objc_name="label") +SharedEventHandle_label :: proc(self: ^SharedEventHandle) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + SharedEventListener +Class Methods: + alloc +Methods: + dispatchQueue + init + initWithDispatchQueue +*/ +@(objc_class="MTLSharedEventListener") +SharedEventListener :: struct { using _: NS.Object } + +@(objc_type=SharedEventListener, objc_class_name="alloc") +SharedEventListener_alloc :: proc() -> ^SharedEventListener { + return msgSend(^SharedEventListener, SharedEventListener, "alloc") +} +@(objc_type=SharedEventListener, objc_name="dispatchQueue") +SharedEventListener_dispatchQueue :: proc(self: ^SharedEventListener) -> NS.Integer { + return msgSend(NS.Integer, self, "dispatchQueue") +} +@(objc_type=SharedEventListener, objc_name="init") +SharedEventListener_init :: proc(self: ^SharedEventListener) -> ^SharedEventListener { + return msgSend(^SharedEventListener, self, "init") +} +@(objc_type=SharedEventListener, objc_name="initWithDispatchQueue") +SharedEventListener_initWithDispatchQueue :: proc(self: ^SharedEventListener, dispatchQueue: ^NS.Object) -> ^SharedEventListener { + return msgSend(^SharedEventListener, self, "initWithDispatchQueue:", dispatchQueue) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + SharedTextureHandle +Class Methods: + alloc +Methods: + init + device + label +*/ +@(objc_class="MTLSharedTextureHandle") +SharedTextureHandle :: struct { using _: NS.Object } + +@(objc_type=SharedTextureHandle, objc_class_name="alloc") +SharedTextureHandle_alloc :: proc() -> ^SharedTextureHandle { + return msgSend(^SharedTextureHandle, SharedTextureHandle, "alloc") +} +@(objc_type=SharedTextureHandle, objc_name="init") +SharedTextureHandle_init :: proc(self: ^SharedTextureHandle) -> ^SharedTextureHandle { + return msgSend(^SharedTextureHandle, self, "init") +} +@(objc_type=SharedTextureHandle, objc_name="device") +SharedTextureHandle_device :: proc(self: ^SharedTextureHandle) -> ^SharedTextureHandle { + return msgSend(^SharedTextureHandle, self, "device") +} +@(objc_type=SharedTextureHandle, objc_name="label") +SharedTextureHandle_label :: proc(self: ^SharedTextureHandle) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + StageInputOutputDescriptor +Class Methods: + alloc + stageInputOutputDescriptor +Methods: + init + attributes + indexBufferIndex + indexType + layouts + reset + setIndexBufferIndex + setIndexType +*/ +@(objc_class="MTLStageInputOutputDescriptor") +StageInputOutputDescriptor :: struct { using _: NS.Copying(StageInputOutputDescriptor) } + +@(objc_type=StageInputOutputDescriptor, objc_class_name="alloc") +StageInputOutputDescriptor_alloc :: proc() -> ^StageInputOutputDescriptor { + return msgSend(^StageInputOutputDescriptor, StageInputOutputDescriptor, "alloc") +} +@(objc_type=StageInputOutputDescriptor, objc_name="init") +StageInputOutputDescriptor_init :: proc(self: ^StageInputOutputDescriptor) -> ^StageInputOutputDescriptor { + return msgSend(^StageInputOutputDescriptor, self, "init") +} +@(objc_type=StageInputOutputDescriptor, objc_name="attributes") +StageInputOutputDescriptor_attributes :: proc(self: ^StageInputOutputDescriptor) -> ^AttributeDescriptorArray { + return msgSend(^AttributeDescriptorArray, self, "attributes") +} +@(objc_type=StageInputOutputDescriptor, objc_name="indexBufferIndex") +StageInputOutputDescriptor_indexBufferIndex :: proc(self: ^StageInputOutputDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "indexBufferIndex") +} +@(objc_type=StageInputOutputDescriptor, objc_name="indexType") +StageInputOutputDescriptor_indexType :: proc(self: ^StageInputOutputDescriptor) -> IndexType { + return msgSend(IndexType, self, "indexType") +} +@(objc_type=StageInputOutputDescriptor, objc_name="layouts") +StageInputOutputDescriptor_layouts :: proc(self: ^StageInputOutputDescriptor) -> ^BufferLayoutDescriptorArray { + return msgSend(^BufferLayoutDescriptorArray, self, "layouts") +} +@(objc_type=StageInputOutputDescriptor, objc_name="reset") +StageInputOutputDescriptor_reset :: proc(self: ^StageInputOutputDescriptor) { + msgSend(nil, self, "reset") +} +@(objc_type=StageInputOutputDescriptor, objc_name="setIndexBufferIndex") +StageInputOutputDescriptor_setIndexBufferIndex :: proc(self: ^StageInputOutputDescriptor, indexBufferIndex: NS.Integer) { + msgSend(nil, self, "setIndexBufferIndex:", indexBufferIndex) +} +@(objc_type=StageInputOutputDescriptor, objc_name="setIndexType") +StageInputOutputDescriptor_setIndexType :: proc(self: ^StageInputOutputDescriptor, indexType: IndexType) { + msgSend(nil, self, "setIndexType:", indexType) +} +@(objc_type=StageInputOutputDescriptor, objc_class_name="stageInputOutputDescriptor") +StageInputOutputDescriptor_stageInputOutputDescriptor :: proc() -> ^StageInputOutputDescriptor { + return msgSend(^StageInputOutputDescriptor, StageInputOutputDescriptor, "stageInputOutputDescriptor") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + StencilDescriptor +Class Methods: + alloc +Methods: + init + depthFailureOperation + depthStencilPassOperation + readMask + setDepthFailureOperation + setDepthStencilPassOperation + setReadMask + setStencilCompareFunction + setStencilFailureOperation + setWriteMask + stencilCompareFunction + stencilFailureOperation + writeMask +*/ +@(objc_class="MTLStencilDescriptor") +StencilDescriptor :: struct { using _: NS.Copying(StencilDescriptor) } + +@(objc_type=StencilDescriptor, objc_class_name="alloc") +StencilDescriptor_alloc :: proc() -> ^StencilDescriptor { + return msgSend(^StencilDescriptor, StencilDescriptor, "alloc") +} +@(objc_type=StencilDescriptor, objc_name="init") +StencilDescriptor_init :: proc(self: ^StencilDescriptor) -> ^StencilDescriptor { + return msgSend(^StencilDescriptor, self, "init") +} +@(objc_type=StencilDescriptor, objc_name="depthFailureOperation") +StencilDescriptor_depthFailureOperation :: proc(self: ^StencilDescriptor) -> StencilOperation { + return msgSend(StencilOperation, self, "depthFailureOperation") +} +@(objc_type=StencilDescriptor, objc_name="depthStencilPassOperation") +StencilDescriptor_depthStencilPassOperation :: proc(self: ^StencilDescriptor) -> StencilOperation { + return msgSend(StencilOperation, self, "depthStencilPassOperation") +} +@(objc_type=StencilDescriptor, objc_name="readMask") +StencilDescriptor_readMask :: proc(self: ^StencilDescriptor) -> u32 { + return msgSend(u32, self, "readMask") +} +@(objc_type=StencilDescriptor, objc_name="setDepthFailureOperation") +StencilDescriptor_setDepthFailureOperation :: proc(self: ^StencilDescriptor, depthFailureOperation: StencilOperation) { + msgSend(nil, self, "setDepthFailureOperation:", depthFailureOperation) +} +@(objc_type=StencilDescriptor, objc_name="setDepthStencilPassOperation") +StencilDescriptor_setDepthStencilPassOperation :: proc(self: ^StencilDescriptor, depthStencilPassOperation: StencilOperation) { + msgSend(nil, self, "setDepthStencilPassOperation:", depthStencilPassOperation) +} +@(objc_type=StencilDescriptor, objc_name="setReadMask") +StencilDescriptor_setReadMask :: proc(self: ^StencilDescriptor, readMask: u32) { + msgSend(nil, self, "setReadMask:", readMask) +} +@(objc_type=StencilDescriptor, objc_name="setStencilCompareFunction") +StencilDescriptor_setStencilCompareFunction :: proc(self: ^StencilDescriptor, stencilCompareFunction: CompareFunction) { + msgSend(nil, self, "setStencilCompareFunction:", stencilCompareFunction) +} +@(objc_type=StencilDescriptor, objc_name="setStencilFailureOperation") +StencilDescriptor_setStencilFailureOperation :: proc(self: ^StencilDescriptor, stencilFailureOperation: StencilOperation) { + msgSend(nil, self, "setStencilFailureOperation:", stencilFailureOperation) +} +@(objc_type=StencilDescriptor, objc_name="setWriteMask") +StencilDescriptor_setWriteMask :: proc(self: ^StencilDescriptor, writeMask: u32) { + msgSend(nil, self, "setWriteMask:", writeMask) +} +@(objc_type=StencilDescriptor, objc_name="stencilCompareFunction") +StencilDescriptor_stencilCompareFunction :: proc(self: ^StencilDescriptor) -> CompareFunction { + return msgSend(CompareFunction, self, "stencilCompareFunction") +} +@(objc_type=StencilDescriptor, objc_name="stencilFailureOperation") +StencilDescriptor_stencilFailureOperation :: proc(self: ^StencilDescriptor) -> StencilOperation { + return msgSend(StencilOperation, self, "stencilFailureOperation") +} +@(objc_type=StencilDescriptor, objc_name="writeMask") +StencilDescriptor_writeMask :: proc(self: ^StencilDescriptor) -> u32 { + return msgSend(u32, self, "writeMask") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + StructMember +Class Methods: + alloc +Methods: + init + argumentIndex + arrayType + dataType + name + offset + pointerType + structType + textureReferenceType +*/ +@(objc_class="MTLStructMember") +StructMember :: struct { using _: NS.Object } + +@(objc_type=StructMember, objc_class_name="alloc") +StructMember_alloc :: proc() -> ^StructMember { + return msgSend(^StructMember, StructMember, "alloc") +} +@(objc_type=StructMember, objc_name="init") +StructMember_init :: proc(self: ^StructMember) -> ^StructMember { + return msgSend(^StructMember, self, "init") +} +@(objc_type=StructMember, objc_name="argumentIndex") +StructMember_argumentIndex :: proc(self: ^StructMember) -> NS.Integer { + return msgSend(NS.Integer, self, "argumentIndex") +} +@(objc_type=StructMember, objc_name="arrayType") +StructMember_arrayType :: proc(self: ^StructMember) -> ^ArrayType { + return msgSend(^ArrayType, self, "arrayType") +} +@(objc_type=StructMember, objc_name="dataType") +StructMember_dataType :: proc(self: ^StructMember) -> DataType { + return msgSend(DataType, self, "dataType") +} +@(objc_type=StructMember, objc_name="name") +StructMember_name :: proc(self: ^StructMember) -> ^NS.String { + return msgSend(^NS.String, self, "name") +} +@(objc_type=StructMember, objc_name="offset") +StructMember_offset :: proc(self: ^StructMember) -> NS.Integer { + return msgSend(NS.Integer, self, "offset") +} +@(objc_type=StructMember, objc_name="pointerType") +StructMember_pointerType :: proc(self: ^StructMember) -> ^PointerType { + return msgSend(^PointerType, self, "pointerType") +} +@(objc_type=StructMember, objc_name="structType") +StructMember_structType :: proc(self: ^StructMember) -> ^StructType { + return msgSend(^StructType, self, "structType") +} +@(objc_type=StructMember, objc_name="textureReferenceType") +StructMember_textureReferenceType :: proc(self: ^StructMember) -> ^TextureReferenceType { + return msgSend(^TextureReferenceType, self, "textureReferenceType") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + StructType +Class Methods: + alloc +Methods: + init + memberByName + members +*/ +@(objc_class="MTLStructType") +StructType :: struct { using _: NS.Object } + +@(objc_type=StructType, objc_class_name="alloc") +StructType_alloc :: proc() -> ^StructType { + return msgSend(^StructType, StructType, "alloc") +} +@(objc_type=StructType, objc_name="init") +StructType_init :: proc(self: ^StructType) -> ^StructType { + return msgSend(^StructType, self, "init") +} +@(objc_type=StructType, objc_name="memberByName") +StructType_memberByName :: proc(self: ^StructType, name: ^NS.String) -> ^StructMember { + return msgSend(^StructMember, self, "memberByName:", name) +} +@(objc_type=StructType, objc_name="members") +StructType_members :: proc(self: ^StructType) -> ^NS.Array { + return msgSend(^NS.Array, self, "members") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + TextureDescriptor +Class Methods: + alloc + texture2DDescriptorWithPixelFormat + textureBufferDescriptorWithPixelFormat + textureCubeDescriptorWithPixelFormat +Methods: + init + allowGPUOptimizedContents + arrayLength + cpuCacheMode + depth + hazardTrackingMode + height + mipmapLevelCount + pixelFormat + resourceOptions + sampleCount + setAllowGPUOptimizedContents + setArrayLength + setCpuCacheMode + setDepth + setHazardTrackingMode + setHeight + setMipmapLevelCount + setPixelFormat + setResourceOptions + setSampleCount + setStorageMode + setSwizzle + setTextureType + setUsage + setWidth + storageMode + swizzle + textureType + usage + width +*/ +@(objc_class="MTLTextureDescriptor") +TextureDescriptor :: struct { using _: NS.Copying(TextureDescriptor) } + +@(objc_type=TextureDescriptor, objc_class_name="alloc") +TextureDescriptor_alloc :: proc() -> ^TextureDescriptor { + return msgSend(^TextureDescriptor, TextureDescriptor, "alloc") +} +@(objc_type=TextureDescriptor, objc_name="init") +TextureDescriptor_init :: proc(self: ^TextureDescriptor) -> ^TextureDescriptor { + return msgSend(^TextureDescriptor, self, "init") +} +@(objc_type=TextureDescriptor, objc_name="allowGPUOptimizedContents") +TextureDescriptor_allowGPUOptimizedContents :: proc(self: ^TextureDescriptor) -> BOOL { + return msgSend(BOOL, self, "allowGPUOptimizedContents") +} +@(objc_type=TextureDescriptor, objc_name="arrayLength") +TextureDescriptor_arrayLength :: proc(self: ^TextureDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "arrayLength") +} +@(objc_type=TextureDescriptor, objc_name="cpuCacheMode") +TextureDescriptor_cpuCacheMode :: proc(self: ^TextureDescriptor) -> CPUCacheMode { + return msgSend(CPUCacheMode, self, "cpuCacheMode") +} +@(objc_type=TextureDescriptor, objc_name="depth") +TextureDescriptor_depth :: proc(self: ^TextureDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "depth") +} +@(objc_type=TextureDescriptor, objc_name="hazardTrackingMode") +TextureDescriptor_hazardTrackingMode :: proc(self: ^TextureDescriptor) -> HazardTrackingMode { + return msgSend(HazardTrackingMode, self, "hazardTrackingMode") +} +@(objc_type=TextureDescriptor, objc_name="height") +TextureDescriptor_height :: proc(self: ^TextureDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "height") +} +@(objc_type=TextureDescriptor, objc_name="mipmapLevelCount") +TextureDescriptor_mipmapLevelCount :: proc(self: ^TextureDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "mipmapLevelCount") +} +@(objc_type=TextureDescriptor, objc_name="pixelFormat") +TextureDescriptor_pixelFormat :: proc(self: ^TextureDescriptor) -> PixelFormat { + return msgSend(PixelFormat, self, "pixelFormat") +} +@(objc_type=TextureDescriptor, objc_name="resourceOptions") +TextureDescriptor_resourceOptions :: proc(self: ^TextureDescriptor) -> ResourceOptions { + return msgSend(ResourceOptions, self, "resourceOptions") +} +@(objc_type=TextureDescriptor, objc_name="sampleCount") +TextureDescriptor_sampleCount :: proc(self: ^TextureDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "sampleCount") +} +@(objc_type=TextureDescriptor, objc_name="setAllowGPUOptimizedContents") +TextureDescriptor_setAllowGPUOptimizedContents :: proc(self: ^TextureDescriptor, allowGPUOptimizedContents: BOOL) { + msgSend(nil, self, "setAllowGPUOptimizedContents:", allowGPUOptimizedContents) +} +@(objc_type=TextureDescriptor, objc_name="setArrayLength") +TextureDescriptor_setArrayLength :: proc(self: ^TextureDescriptor, arrayLength: NS.Integer) { + msgSend(nil, self, "setArrayLength:", arrayLength) +} +@(objc_type=TextureDescriptor, objc_name="setCpuCacheMode") +TextureDescriptor_setCpuCacheMode :: proc(self: ^TextureDescriptor, cpuCacheMode: CPUCacheMode) { + msgSend(nil, self, "setCpuCacheMode:", cpuCacheMode) +} +@(objc_type=TextureDescriptor, objc_name="setDepth") +TextureDescriptor_setDepth :: proc(self: ^TextureDescriptor, depth: NS.Integer) { + msgSend(nil, self, "setDepth:", depth) +} +@(objc_type=TextureDescriptor, objc_name="setHazardTrackingMode") +TextureDescriptor_setHazardTrackingMode :: proc(self: ^TextureDescriptor, hazardTrackingMode: HazardTrackingMode) { + msgSend(nil, self, "setHazardTrackingMode:", hazardTrackingMode) +} +@(objc_type=TextureDescriptor, objc_name="setHeight") +TextureDescriptor_setHeight :: proc(self: ^TextureDescriptor, height: NS.Integer) { + msgSend(nil, self, "setHeight:", height) +} +@(objc_type=TextureDescriptor, objc_name="setMipmapLevelCount") +TextureDescriptor_setMipmapLevelCount :: proc(self: ^TextureDescriptor, mipmapLevelCount: NS.Integer) { + msgSend(nil, self, "setMipmapLevelCount:", mipmapLevelCount) +} +@(objc_type=TextureDescriptor, objc_name="setPixelFormat") +TextureDescriptor_setPixelFormat :: proc(self: ^TextureDescriptor, pixelFormat: PixelFormat) { + msgSend(nil, self, "setPixelFormat:", pixelFormat) +} +@(objc_type=TextureDescriptor, objc_name="setResourceOptions") +TextureDescriptor_setResourceOptions :: proc(self: ^TextureDescriptor, resourceOptions: ResourceOptions) { + msgSend(nil, self, "setResourceOptions:", resourceOptions) +} +@(objc_type=TextureDescriptor, objc_name="setSampleCount") +TextureDescriptor_setSampleCount :: proc(self: ^TextureDescriptor, sampleCount: NS.Integer) { + msgSend(nil, self, "setSampleCount:", sampleCount) +} +@(objc_type=TextureDescriptor, objc_name="setStorageMode") +TextureDescriptor_setStorageMode :: proc(self: ^TextureDescriptor, storageMode: StorageMode) { + msgSend(nil, self, "setStorageMode:", storageMode) +} +@(objc_type=TextureDescriptor, objc_name="setSwizzle") +TextureDescriptor_setSwizzle :: proc(self: ^TextureDescriptor, swizzle: TextureSwizzleChannels) { + msgSend(nil, self, "setSwizzle:", swizzle) +} +@(objc_type=TextureDescriptor, objc_name="setTextureType") +TextureDescriptor_setTextureType :: proc(self: ^TextureDescriptor, textureType: TextureType) { + msgSend(nil, self, "setTextureType:", textureType) +} +@(objc_type=TextureDescriptor, objc_name="setUsage") +TextureDescriptor_setUsage :: proc(self: ^TextureDescriptor, usage: TextureUsage) { + msgSend(nil, self, "setUsage:", usage) +} +@(objc_type=TextureDescriptor, objc_name="setWidth") +TextureDescriptor_setWidth :: proc(self: ^TextureDescriptor, width: NS.Integer) { + msgSend(nil, self, "setWidth:", width) +} +@(objc_type=TextureDescriptor, objc_name="storageMode") +TextureDescriptor_storageMode :: proc(self: ^TextureDescriptor) -> StorageMode { + return msgSend(StorageMode, self, "storageMode") +} +@(objc_type=TextureDescriptor, objc_name="swizzle") +TextureDescriptor_swizzle :: proc(self: ^TextureDescriptor) -> TextureSwizzleChannels { + return msgSend(TextureSwizzleChannels, self, "swizzle") +} +@(objc_type=TextureDescriptor, objc_class_name="texture2DDescriptorWithPixelFormat") +TextureDescriptor_texture2DDescriptorWithPixelFormat :: proc(pixelFormat: PixelFormat, width: ^NS.Object, height: ^NS.Object, mipmapped: BOOL) -> ^TextureDescriptor { + return msgSend(^TextureDescriptor, TextureDescriptor, "texture2DDescriptorWithPixelFormat:width:height:mipmapped:", pixelFormat, width, height, mipmapped) +} +@(objc_type=TextureDescriptor, objc_class_name="textureBufferDescriptorWithPixelFormat") +TextureDescriptor_textureBufferDescriptorWithPixelFormat :: proc(pixelFormat: PixelFormat, width: ^NS.Object, resourceOptions: ResourceOptions, usage: TextureUsage) -> ^TextureDescriptor { + return msgSend(^TextureDescriptor, TextureDescriptor, "textureBufferDescriptorWithPixelFormat:width:resourceOptions:usage:", pixelFormat, width, resourceOptions, usage) +} +@(objc_type=TextureDescriptor, objc_class_name="textureCubeDescriptorWithPixelFormat") +TextureDescriptor_textureCubeDescriptorWithPixelFormat :: proc(pixelFormat: PixelFormat, size: ^NS.Object, mipmapped: BOOL) -> ^TextureDescriptor { + return msgSend(^TextureDescriptor, TextureDescriptor, "textureCubeDescriptorWithPixelFormat:size:mipmapped:", pixelFormat, size, mipmapped) +} +@(objc_type=TextureDescriptor, objc_name="textureType") +TextureDescriptor_textureType :: proc(self: ^TextureDescriptor) -> TextureType { + return msgSend(TextureType, self, "textureType") +} +@(objc_type=TextureDescriptor, objc_name="usage") +TextureDescriptor_usage :: proc(self: ^TextureDescriptor) -> TextureUsage { + return msgSend(TextureUsage, self, "usage") +} +@(objc_type=TextureDescriptor, objc_name="width") +TextureDescriptor_width :: proc(self: ^TextureDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "width") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + TextureReferenceType +Class Methods: + alloc +Methods: + init + access + isDepthTexture + textureDataType + textureType +*/ +@(objc_class="MTLTextureReferenceType") +TextureReferenceType :: struct { using _: NS.Object } + +@(objc_type=TextureReferenceType, objc_class_name="alloc") +TextureReferenceType_alloc :: proc() -> ^TextureReferenceType { + return msgSend(^TextureReferenceType, TextureReferenceType, "alloc") +} +@(objc_type=TextureReferenceType, objc_name="init") +TextureReferenceType_init :: proc(self: ^TextureReferenceType) -> ^TextureReferenceType { + return msgSend(^TextureReferenceType, self, "init") +} +@(objc_type=TextureReferenceType, objc_name="access") +TextureReferenceType_access :: proc(self: ^TextureReferenceType) -> ArgumentAccess { + return msgSend(ArgumentAccess, self, "access") +} +@(objc_type=TextureReferenceType, objc_name="isDepthTexture") +TextureReferenceType_isDepthTexture :: proc(self: ^TextureReferenceType) -> BOOL { + return msgSend(BOOL, self, "isDepthTexture") +} +@(objc_type=TextureReferenceType, objc_name="textureDataType") +TextureReferenceType_textureDataType :: proc(self: ^TextureReferenceType) -> DataType { + return msgSend(DataType, self, "textureDataType") +} +@(objc_type=TextureReferenceType, objc_name="textureType") +TextureReferenceType_textureType :: proc(self: ^TextureReferenceType) -> TextureType { + return msgSend(TextureType, self, "textureType") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + TileRenderPipelineColorAttachmentDescriptor +Class Methods: + alloc +Methods: + init + pixelFormat + setPixelFormat +*/ +@(objc_class="MTLTileRenderPipelineColorAttachmentDescriptor") +TileRenderPipelineColorAttachmentDescriptor :: struct { using _: NS.Copying(TileRenderPipelineColorAttachmentDescriptor) } + +@(objc_type=TileRenderPipelineColorAttachmentDescriptor, objc_class_name="alloc") +TileRenderPipelineColorAttachmentDescriptor_alloc :: proc() -> ^TileRenderPipelineColorAttachmentDescriptor { + return msgSend(^TileRenderPipelineColorAttachmentDescriptor, TileRenderPipelineColorAttachmentDescriptor, "alloc") +} +@(objc_type=TileRenderPipelineColorAttachmentDescriptor, objc_name="init") +TileRenderPipelineColorAttachmentDescriptor_init :: proc(self: ^TileRenderPipelineColorAttachmentDescriptor) -> ^TileRenderPipelineColorAttachmentDescriptor { + return msgSend(^TileRenderPipelineColorAttachmentDescriptor, self, "init") +} +@(objc_type=TileRenderPipelineColorAttachmentDescriptor, objc_name="pixelFormat") +TileRenderPipelineColorAttachmentDescriptor_pixelFormat :: proc(self: ^TileRenderPipelineColorAttachmentDescriptor) -> PixelFormat { + return msgSend(PixelFormat, self, "pixelFormat") +} +@(objc_type=TileRenderPipelineColorAttachmentDescriptor, objc_name="setPixelFormat") +TileRenderPipelineColorAttachmentDescriptor_setPixelFormat :: proc(self: ^TileRenderPipelineColorAttachmentDescriptor, pixelFormat: PixelFormat) { + msgSend(nil, self, "setPixelFormat:", pixelFormat) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + TileRenderPipelineColorAttachmentDescriptorArray +Class Methods: + alloc +Methods: + init + objectAtIndexedSubscript + setObject +*/ +@(objc_class="MTLTileRenderPipelineColorAttachmentDescriptorArray") +TileRenderPipelineColorAttachmentDescriptorArray :: struct { using _: NS.Object } + +@(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_class_name="alloc") +TileRenderPipelineColorAttachmentDescriptorArray_alloc :: proc() -> ^TileRenderPipelineColorAttachmentDescriptorArray { + return msgSend(^TileRenderPipelineColorAttachmentDescriptorArray, TileRenderPipelineColorAttachmentDescriptorArray, "alloc") +} +@(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_name="init") +TileRenderPipelineColorAttachmentDescriptorArray_init :: proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray) -> ^TileRenderPipelineColorAttachmentDescriptorArray { + return msgSend(^TileRenderPipelineColorAttachmentDescriptorArray, self, "init") +} +@(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") +TileRenderPipelineColorAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^TileRenderPipelineColorAttachmentDescriptor { + return msgSend(^TileRenderPipelineColorAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) +} +@(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_name="setObject") +TileRenderPipelineColorAttachmentDescriptorArray_setObject :: proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray, attachment: ^TileRenderPipelineColorAttachmentDescriptor, attachmentIndex: ^NS.Object) { + msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + TileRenderPipelineDescriptor +Class Methods: + alloc +Methods: + init + binaryArchives + colorAttachments + label + maxTotalThreadsPerThreadgroup + rasterSampleCount + reset + setBinaryArchives + setLabel + setMaxTotalThreadsPerThreadgroup + setRasterSampleCount + setThreadgroupSizeMatchesTileSize + setTileFunction + threadgroupSizeMatchesTileSize + tileBuffers + tileFunction +*/ +@(objc_class="MTLTileRenderPipelineDescriptor") +TileRenderPipelineDescriptor :: struct { using _: NS.Copying(TileRenderPipelineDescriptor) } + +@(objc_type=TileRenderPipelineDescriptor, objc_class_name="alloc") +TileRenderPipelineDescriptor_alloc :: proc() -> ^TileRenderPipelineDescriptor { + return msgSend(^TileRenderPipelineDescriptor, TileRenderPipelineDescriptor, "alloc") +} +@(objc_type=TileRenderPipelineDescriptor, objc_name="init") +TileRenderPipelineDescriptor_init :: proc(self: ^TileRenderPipelineDescriptor) -> ^TileRenderPipelineDescriptor { + return msgSend(^TileRenderPipelineDescriptor, self, "init") +} +@(objc_type=TileRenderPipelineDescriptor, objc_name="binaryArchives") +TileRenderPipelineDescriptor_binaryArchives :: proc(self: ^TileRenderPipelineDescriptor) -> ^NS.Array { + return msgSend(^NS.Array, self, "binaryArchives") +} +@(objc_type=TileRenderPipelineDescriptor, objc_name="colorAttachments") +TileRenderPipelineDescriptor_colorAttachments :: proc(self: ^TileRenderPipelineDescriptor) -> ^TileRenderPipelineColorAttachmentDescriptorArray { + return msgSend(^TileRenderPipelineColorAttachmentDescriptorArray, self, "colorAttachments") +} +@(objc_type=TileRenderPipelineDescriptor, objc_name="label") +TileRenderPipelineDescriptor_label :: proc(self: ^TileRenderPipelineDescriptor) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=TileRenderPipelineDescriptor, objc_name="maxTotalThreadsPerThreadgroup") +TileRenderPipelineDescriptor_maxTotalThreadsPerThreadgroup :: proc(self: ^TileRenderPipelineDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "maxTotalThreadsPerThreadgroup") +} +@(objc_type=TileRenderPipelineDescriptor, objc_name="rasterSampleCount") +TileRenderPipelineDescriptor_rasterSampleCount :: proc(self: ^TileRenderPipelineDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "rasterSampleCount") +} +@(objc_type=TileRenderPipelineDescriptor, objc_name="reset") +TileRenderPipelineDescriptor_reset :: proc(self: ^TileRenderPipelineDescriptor) { + msgSend(nil, self, "reset") +} +@(objc_type=TileRenderPipelineDescriptor, objc_name="setBinaryArchives") +TileRenderPipelineDescriptor_setBinaryArchives :: proc(self: ^TileRenderPipelineDescriptor, binaryArchives: ^NS.Array) { + msgSend(nil, self, "setBinaryArchives:", binaryArchives) +} +@(objc_type=TileRenderPipelineDescriptor, objc_name="setLabel") +TileRenderPipelineDescriptor_setLabel :: proc(self: ^TileRenderPipelineDescriptor, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} +@(objc_type=TileRenderPipelineDescriptor, objc_name="setMaxTotalThreadsPerThreadgroup") +TileRenderPipelineDescriptor_setMaxTotalThreadsPerThreadgroup :: proc(self: ^TileRenderPipelineDescriptor, maxTotalThreadsPerThreadgroup: NS.Integer) { + msgSend(nil, self, "setMaxTotalThreadsPerThreadgroup:", maxTotalThreadsPerThreadgroup) +} +@(objc_type=TileRenderPipelineDescriptor, objc_name="setRasterSampleCount") +TileRenderPipelineDescriptor_setRasterSampleCount :: proc(self: ^TileRenderPipelineDescriptor, rasterSampleCount: NS.Integer) { + msgSend(nil, self, "setRasterSampleCount:", rasterSampleCount) +} +@(objc_type=TileRenderPipelineDescriptor, objc_name="setThreadgroupSizeMatchesTileSize") +TileRenderPipelineDescriptor_setThreadgroupSizeMatchesTileSize :: proc(self: ^TileRenderPipelineDescriptor, threadgroupSizeMatchesTileSize: BOOL) { + msgSend(nil, self, "setThreadgroupSizeMatchesTileSize:", threadgroupSizeMatchesTileSize) +} +@(objc_type=TileRenderPipelineDescriptor, objc_name="setTileFunction") +TileRenderPipelineDescriptor_setTileFunction :: proc(self: ^TileRenderPipelineDescriptor, tileFunction: ^NS.Object) { + msgSend(nil, self, "setTileFunction:", tileFunction) +} +@(objc_type=TileRenderPipelineDescriptor, objc_name="threadgroupSizeMatchesTileSize") +TileRenderPipelineDescriptor_threadgroupSizeMatchesTileSize :: proc(self: ^TileRenderPipelineDescriptor) -> BOOL { + return msgSend(BOOL, self, "threadgroupSizeMatchesTileSize") +} +@(objc_type=TileRenderPipelineDescriptor, objc_name="tileBuffers") +TileRenderPipelineDescriptor_tileBuffers :: proc(self: ^TileRenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray { + return msgSend(^PipelineBufferDescriptorArray, self, "tileBuffers") +} +@(objc_type=TileRenderPipelineDescriptor, objc_name="tileFunction") +TileRenderPipelineDescriptor_tileFunction :: proc(self: ^TileRenderPipelineDescriptor) -> ^TileRenderPipelineDescriptor { + return msgSend(^TileRenderPipelineDescriptor, self, "tileFunction") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + Type +Class Methods: + alloc +Methods: + init + dataType +*/ +@(objc_class="MTLType") +Type :: struct { using _: NS.Object } + +@(objc_type=Type, objc_class_name="alloc") +Type_alloc :: proc() -> ^Type { + return msgSend(^Type, Type, "alloc") +} +@(objc_type=Type, objc_name="init") +Type_init :: proc(self: ^Type) -> ^Type { + return msgSend(^Type, self, "init") +} +@(objc_type=Type, objc_name="dataType") +Type_dataType :: proc(self: ^Type) -> DataType { + return msgSend(DataType, self, "dataType") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + VertexAttribute +Class Methods: + alloc +Methods: + init + attributeIndex + attributeType + isActive + isPatchControlPointData + isPatchData + name +*/ +@(objc_class="MTLVertexAttribute") +VertexAttribute :: struct { using _: NS.Object } + +@(objc_type=VertexAttribute, objc_class_name="alloc") +VertexAttribute_alloc :: proc() -> ^VertexAttribute { + return msgSend(^VertexAttribute, VertexAttribute, "alloc") +} +@(objc_type=VertexAttribute, objc_name="init") +VertexAttribute_init :: proc(self: ^VertexAttribute) -> ^VertexAttribute { + return msgSend(^VertexAttribute, self, "init") +} +@(objc_type=VertexAttribute, objc_name="attributeIndex") +VertexAttribute_attributeIndex :: proc(self: ^VertexAttribute) -> NS.Integer { + return msgSend(NS.Integer, self, "attributeIndex") +} +@(objc_type=VertexAttribute, objc_name="attributeType") +VertexAttribute_attributeType :: proc(self: ^VertexAttribute) -> DataType { + return msgSend(DataType, self, "attributeType") +} +@(objc_type=VertexAttribute, objc_name="isActive") +VertexAttribute_isActive :: proc(self: ^VertexAttribute) -> BOOL { + return msgSend(BOOL, self, "isActive") +} +@(objc_type=VertexAttribute, objc_name="isPatchControlPointData") +VertexAttribute_isPatchControlPointData :: proc(self: ^VertexAttribute) -> BOOL { + return msgSend(BOOL, self, "isPatchControlPointData") +} +@(objc_type=VertexAttribute, objc_name="isPatchData") +VertexAttribute_isPatchData :: proc(self: ^VertexAttribute) -> BOOL { + return msgSend(BOOL, self, "isPatchData") +} +@(objc_type=VertexAttribute, objc_name="name") +VertexAttribute_name :: proc(self: ^VertexAttribute) -> ^NS.String { + return msgSend(^NS.String, self, "name") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + VertexAttributeDescriptor +Class Methods: + alloc +Methods: + init + bufferIndex + format + offset + setBufferIndex + setFormat + setOffset +*/ +@(objc_class="MTLVertexAttributeDescriptor") +VertexAttributeDescriptor :: struct { using _: NS.Copying(VertexAttributeDescriptor) } + +@(objc_type=VertexAttributeDescriptor, objc_class_name="alloc") +VertexAttributeDescriptor_alloc :: proc() -> ^VertexAttributeDescriptor { + return msgSend(^VertexAttributeDescriptor, VertexAttributeDescriptor, "alloc") +} +@(objc_type=VertexAttributeDescriptor, objc_name="init") +VertexAttributeDescriptor_init :: proc(self: ^VertexAttributeDescriptor) -> ^VertexAttributeDescriptor { + return msgSend(^VertexAttributeDescriptor, self, "init") +} +@(objc_type=VertexAttributeDescriptor, objc_name="bufferIndex") +VertexAttributeDescriptor_bufferIndex :: proc(self: ^VertexAttributeDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "bufferIndex") +} +@(objc_type=VertexAttributeDescriptor, objc_name="format") +VertexAttributeDescriptor_format :: proc(self: ^VertexAttributeDescriptor) -> VertexFormat { + return msgSend(VertexFormat, self, "format") +} +@(objc_type=VertexAttributeDescriptor, objc_name="offset") +VertexAttributeDescriptor_offset :: proc(self: ^VertexAttributeDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "offset") +} +@(objc_type=VertexAttributeDescriptor, objc_name="setBufferIndex") +VertexAttributeDescriptor_setBufferIndex :: proc(self: ^VertexAttributeDescriptor, bufferIndex: NS.Integer) { + msgSend(nil, self, "setBufferIndex:", bufferIndex) +} +@(objc_type=VertexAttributeDescriptor, objc_name="setFormat") +VertexAttributeDescriptor_setFormat :: proc(self: ^VertexAttributeDescriptor, format: VertexFormat) { + msgSend(nil, self, "setFormat:", format) +} +@(objc_type=VertexAttributeDescriptor, objc_name="setOffset") +VertexAttributeDescriptor_setOffset :: proc(self: ^VertexAttributeDescriptor, offset: NS.Integer) { + msgSend(nil, self, "setOffset:", offset) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + VertexAttributeDescriptorArray +Class Methods: + alloc +Methods: + init + objectAtIndexedSubscript + setObject +*/ +@(objc_class="MTLVertexAttributeDescriptorArray") +VertexAttributeDescriptorArray :: struct { using _: NS.Object } + +@(objc_type=VertexAttributeDescriptorArray, objc_class_name="alloc") +VertexAttributeDescriptorArray_alloc :: proc() -> ^VertexAttributeDescriptorArray { + return msgSend(^VertexAttributeDescriptorArray, VertexAttributeDescriptorArray, "alloc") +} +@(objc_type=VertexAttributeDescriptorArray, objc_name="init") +VertexAttributeDescriptorArray_init :: proc(self: ^VertexAttributeDescriptorArray) -> ^VertexAttributeDescriptorArray { + return msgSend(^VertexAttributeDescriptorArray, self, "init") +} +@(objc_type=VertexAttributeDescriptorArray, objc_name="objectAtIndexedSubscript") +VertexAttributeDescriptorArray_objectAtIndexedSubscript :: proc(self: ^VertexAttributeDescriptorArray, index: ^NS.Object) -> ^VertexAttributeDescriptor { + return msgSend(^VertexAttributeDescriptor, self, "objectAtIndexedSubscript:", index) +} +@(objc_type=VertexAttributeDescriptorArray, objc_name="setObject") +VertexAttributeDescriptorArray_setObject :: proc(self: ^VertexAttributeDescriptorArray, attributeDesc: ^VertexAttributeDescriptor, index: ^NS.Object) { + msgSend(nil, self, "setObject:atIndexedSubscript:", attributeDesc, index) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + VertexBufferLayoutDescriptor +Class Methods: + alloc +Methods: + init + setStepFunction + setStepRate + setStride + stepFunction + stepRate + stride +*/ +@(objc_class="MTLVertexBufferLayoutDescriptor") +VertexBufferLayoutDescriptor :: struct { using _: NS.Copying(VertexBufferLayoutDescriptor) } + +@(objc_type=VertexBufferLayoutDescriptor, objc_class_name="alloc") +VertexBufferLayoutDescriptor_alloc :: proc() -> ^VertexBufferLayoutDescriptor { + return msgSend(^VertexBufferLayoutDescriptor, VertexBufferLayoutDescriptor, "alloc") +} +@(objc_type=VertexBufferLayoutDescriptor, objc_name="init") +VertexBufferLayoutDescriptor_init :: proc(self: ^VertexBufferLayoutDescriptor) -> ^VertexBufferLayoutDescriptor { + return msgSend(^VertexBufferLayoutDescriptor, self, "init") +} +@(objc_type=VertexBufferLayoutDescriptor, objc_name="setStepFunction") +VertexBufferLayoutDescriptor_setStepFunction :: proc(self: ^VertexBufferLayoutDescriptor, stepFunction: VertexStepFunction) { + msgSend(nil, self, "setStepFunction:", stepFunction) +} +@(objc_type=VertexBufferLayoutDescriptor, objc_name="setStepRate") +VertexBufferLayoutDescriptor_setStepRate :: proc(self: ^VertexBufferLayoutDescriptor, stepRate: NS.Integer) { + msgSend(nil, self, "setStepRate:", stepRate) +} +@(objc_type=VertexBufferLayoutDescriptor, objc_name="setStride") +VertexBufferLayoutDescriptor_setStride :: proc(self: ^VertexBufferLayoutDescriptor, stride: NS.Integer) { + msgSend(nil, self, "setStride:", stride) +} +@(objc_type=VertexBufferLayoutDescriptor, objc_name="stepFunction") +VertexBufferLayoutDescriptor_stepFunction :: proc(self: ^VertexBufferLayoutDescriptor) -> VertexStepFunction { + return msgSend(VertexStepFunction, self, "stepFunction") +} +@(objc_type=VertexBufferLayoutDescriptor, objc_name="stepRate") +VertexBufferLayoutDescriptor_stepRate :: proc(self: ^VertexBufferLayoutDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "stepRate") +} +@(objc_type=VertexBufferLayoutDescriptor, objc_name="stride") +VertexBufferLayoutDescriptor_stride :: proc(self: ^VertexBufferLayoutDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "stride") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + VertexBufferLayoutDescriptorArray +Class Methods: + alloc +Methods: + init + objectAtIndexedSubscript + setObject +*/ +@(objc_class="MTLVertexBufferLayoutDescriptorArray") +VertexBufferLayoutDescriptorArray :: struct { using _: NS.Object } + +@(objc_type=VertexBufferLayoutDescriptorArray, objc_class_name="alloc") +VertexBufferLayoutDescriptorArray_alloc :: proc() -> ^VertexBufferLayoutDescriptorArray { + return msgSend(^VertexBufferLayoutDescriptorArray, VertexBufferLayoutDescriptorArray, "alloc") +} +@(objc_type=VertexBufferLayoutDescriptorArray, objc_name="init") +VertexBufferLayoutDescriptorArray_init :: proc(self: ^VertexBufferLayoutDescriptorArray) -> ^VertexBufferLayoutDescriptorArray { + return msgSend(^VertexBufferLayoutDescriptorArray, self, "init") +} +@(objc_type=VertexBufferLayoutDescriptorArray, objc_name="objectAtIndexedSubscript") +VertexBufferLayoutDescriptorArray_objectAtIndexedSubscript :: proc(self: ^VertexBufferLayoutDescriptorArray, index: ^NS.Object) -> ^VertexBufferLayoutDescriptor { + return msgSend(^VertexBufferLayoutDescriptor, self, "objectAtIndexedSubscript:", index) +} +@(objc_type=VertexBufferLayoutDescriptorArray, objc_name="setObject") +VertexBufferLayoutDescriptorArray_setObject :: proc(self: ^VertexBufferLayoutDescriptorArray, bufferDesc: ^VertexBufferLayoutDescriptor, index: ^NS.Object) { + msgSend(nil, self, "setObject:atIndexedSubscript:", bufferDesc, index) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + VertexDescriptor +Class Methods: + alloc + vertexDescriptor +Methods: + init + attributes + layouts + reset +*/ +@(objc_class="MTLVertexDescriptor") +VertexDescriptor :: struct { using _: NS.Copying(VertexDescriptor) } + +@(objc_type=VertexDescriptor, objc_class_name="alloc") +VertexDescriptor_alloc :: proc() -> ^VertexDescriptor { + return msgSend(^VertexDescriptor, VertexDescriptor, "alloc") +} +@(objc_type=VertexDescriptor, objc_name="init") +VertexDescriptor_init :: proc(self: ^VertexDescriptor) -> ^VertexDescriptor { + return msgSend(^VertexDescriptor, self, "init") +} +@(objc_type=VertexDescriptor, objc_name="attributes") +VertexDescriptor_attributes :: proc(self: ^VertexDescriptor) -> ^VertexAttributeDescriptorArray { + return msgSend(^VertexAttributeDescriptorArray, self, "attributes") +} +@(objc_type=VertexDescriptor, objc_name="layouts") +VertexDescriptor_layouts :: proc(self: ^VertexDescriptor) -> ^VertexBufferLayoutDescriptorArray { + return msgSend(^VertexBufferLayoutDescriptorArray, self, "layouts") +} +@(objc_type=VertexDescriptor, objc_name="reset") +VertexDescriptor_reset :: proc(self: ^VertexDescriptor) { + msgSend(nil, self, "reset") +} +@(objc_type=VertexDescriptor, objc_class_name="vertexDescriptor") +VertexDescriptor_vertexDescriptor :: proc() -> ^VertexDescriptor { + return msgSend(^VertexDescriptor, VertexDescriptor, "vertexDescriptor") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + VisibleFunctionTableDescriptor +Class Methods: + alloc + visibleFunctionTableDescriptor +Methods: + init + functionCount + setFunctionCount +*/ +@(objc_class="MTLVisibleFunctionTableDescriptor") +VisibleFunctionTableDescriptor :: struct { using _: NS.Copying(VisibleFunctionTableDescriptor) } + +@(objc_type=VisibleFunctionTableDescriptor, objc_class_name="alloc") +VisibleFunctionTableDescriptor_alloc :: proc() -> ^VisibleFunctionTableDescriptor { + return msgSend(^VisibleFunctionTableDescriptor, VisibleFunctionTableDescriptor, "alloc") +} +@(objc_type=VisibleFunctionTableDescriptor, objc_name="init") +VisibleFunctionTableDescriptor_init :: proc(self: ^VisibleFunctionTableDescriptor) -> ^VisibleFunctionTableDescriptor { + return msgSend(^VisibleFunctionTableDescriptor, self, "init") +} +@(objc_type=VisibleFunctionTableDescriptor, objc_name="functionCount") +VisibleFunctionTableDescriptor_functionCount :: proc(self: ^VisibleFunctionTableDescriptor) -> NS.Integer { + return msgSend(NS.Integer, self, "functionCount") +} +@(objc_type=VisibleFunctionTableDescriptor, objc_name="setFunctionCount") +VisibleFunctionTableDescriptor_setFunctionCount :: proc(self: ^VisibleFunctionTableDescriptor, functionCount: NS.Integer) { + msgSend(nil, self, "setFunctionCount:", functionCount) +} +@(objc_type=VisibleFunctionTableDescriptor, objc_class_name="visibleFunctionTableDescriptor") +VisibleFunctionTableDescriptor_visibleFunctionTableDescriptor :: proc() -> ^VisibleFunctionTableDescriptor { + return msgSend(^VisibleFunctionTableDescriptor, VisibleFunctionTableDescriptor, "visibleFunctionTableDescriptor") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + AccelerationStructure +Class Methods: +Methods: + size +*/ +@(objc_class="MTLAccelerationStructure") +AccelerationStructure :: struct { using _: NS.Object } + +@(objc_type=AccelerationStructure, objc_name="size") +AccelerationStructure_size :: proc(self: ^AccelerationStructure) -> NS.Integer { + return msgSend(NS.Integer, self, "size") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + AccelerationStructureCommandEncoder +Class Methods: +Methods: + buildAccelerationStructure + copyAccelerationStructure + copyAndCompactAccelerationStructure + refitAccelerationStructure + sampleCountersInBuffer + updateFence + useHeap + useHeaps + useResource + useResources + waitForFence + writeCompactedAccelerationStructureSize +*/ +@(objc_class="MTLAccelerationStructureCommandEncoder") +AccelerationStructureCommandEncoder :: struct { using _: NS.Object } + +@(objc_type=AccelerationStructureCommandEncoder, objc_name="buildAccelerationStructure") +AccelerationStructureCommandEncoder_buildAccelerationStructure :: proc(self: ^AccelerationStructureCommandEncoder, accelerationStructure: ^NS.Object, descriptor: ^AccelerationStructureDescriptor, scratchBuffer: ^NS.Object, scratchBufferOffset: ^NS.Object) { + msgSend(nil, self, "buildAccelerationStructure:descriptor:scratchBuffer:scratchBufferOffset:", accelerationStructure, descriptor, scratchBuffer, scratchBufferOffset) +} +@(objc_type=AccelerationStructureCommandEncoder, objc_name="copyAccelerationStructure") +AccelerationStructureCommandEncoder_copyAccelerationStructure :: proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^NS.Object, destinationAccelerationStructure: ^NS.Object) { + msgSend(nil, self, "copyAccelerationStructure:toAccelerationStructure:", sourceAccelerationStructure, destinationAccelerationStructure) +} +@(objc_type=AccelerationStructureCommandEncoder, objc_name="copyAndCompactAccelerationStructure") +AccelerationStructureCommandEncoder_copyAndCompactAccelerationStructure :: proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^NS.Object, destinationAccelerationStructure: ^NS.Object) { + msgSend(nil, self, "copyAndCompactAccelerationStructure:toAccelerationStructure:", sourceAccelerationStructure, destinationAccelerationStructure) +} +@(objc_type=AccelerationStructureCommandEncoder, objc_name="refitAccelerationStructure") +AccelerationStructureCommandEncoder_refitAccelerationStructure :: proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^NS.Object, descriptor: ^AccelerationStructureDescriptor, destinationAccelerationStructure: ^NS.Object, scratchBuffer: ^NS.Object, scratchBufferOffset: ^NS.Object) { + msgSend(nil, self, "refitAccelerationStructure:descriptor:destination:scratchBuffer:scratchBufferOffset:", sourceAccelerationStructure, descriptor, destinationAccelerationStructure, scratchBuffer, scratchBufferOffset) +} +@(objc_type=AccelerationStructureCommandEncoder, objc_name="sampleCountersInBuffer") +AccelerationStructureCommandEncoder_sampleCountersInBuffer :: proc(self: ^AccelerationStructureCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) { + msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier) +} +@(objc_type=AccelerationStructureCommandEncoder, objc_name="updateFence") +AccelerationStructureCommandEncoder_updateFence :: proc(self: ^AccelerationStructureCommandEncoder, fence: ^NS.Object) { + msgSend(nil, self, "updateFence:", fence) +} +@(objc_type=AccelerationStructureCommandEncoder, objc_name="useHeap") +AccelerationStructureCommandEncoder_useHeap :: proc(self: ^AccelerationStructureCommandEncoder, heap: ^NS.Object) { + msgSend(nil, self, "useHeap:", heap) +} +@(objc_type=AccelerationStructureCommandEncoder, objc_name="useHeaps") +AccelerationStructureCommandEncoder_useHeaps :: proc(self: ^AccelerationStructureCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object) { + msgSend(nil, self, "useHeaps:count:", heaps, count) +} +@(objc_type=AccelerationStructureCommandEncoder, objc_name="useResource") +AccelerationStructureCommandEncoder_useResource :: proc(self: ^AccelerationStructureCommandEncoder, resource: ^NS.Object, usage: ResourceUsage) { + msgSend(nil, self, "useResource:usage:", resource, usage) +} +@(objc_type=AccelerationStructureCommandEncoder, objc_name="useResources") +AccelerationStructureCommandEncoder_useResources :: proc(self: ^AccelerationStructureCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage) { + msgSend(nil, self, "useResources:count:usage:", resources, count, usage) +} +@(objc_type=AccelerationStructureCommandEncoder, objc_name="waitForFence") +AccelerationStructureCommandEncoder_waitForFence :: proc(self: ^AccelerationStructureCommandEncoder, fence: ^NS.Object) { + msgSend(nil, self, "waitForFence:", fence) +} +@(objc_type=AccelerationStructureCommandEncoder, objc_name="writeCompactedAccelerationStructureSize") +AccelerationStructureCommandEncoder_writeCompactedAccelerationStructureSize :: proc(self: ^AccelerationStructureCommandEncoder, accelerationStructure: ^NS.Object, buffer: ^NS.Object, offset: ^NS.Object) { + msgSend(nil, self, "writeCompactedAccelerationStructureSize:toBuffer:offset:", accelerationStructure, buffer, offset) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + ArgumentEncoder +Class Methods: +Methods: + alignment + constantDataAtIndex + device + encodedLength + label + newArgumentEncoderForBufferAtIndex + setAccelerationStructure + setArgumentBuffer + setArgumentBuffer + setBuffer + setBuffers + setComputePipelineState + setComputePipelineStates + setIndirectCommandBuffer + setIndirectCommandBuffers + setIntersectionFunctionTable + setIntersectionFunctionTables + setLabel + setRenderPipelineState + setRenderPipelineStates + setSamplerState + setSamplerStates + setTexture + setTextures + setVisibleFunctionTable + setVisibleFunctionTables +*/ +@(objc_class="MTLArgumentEncoder") +ArgumentEncoder :: struct { using _: NS.Object } + +@(objc_type=ArgumentEncoder, objc_name="alignment") +ArgumentEncoder_alignment :: proc(self: ^ArgumentEncoder) -> NS.Integer { + return msgSend(NS.Integer, self, "alignment") +} +@(objc_type=ArgumentEncoder, objc_name="constantDataAtIndex") +ArgumentEncoder_constantDataAtIndex :: proc(self: ^ArgumentEncoder, index: ^NS.Object) -> rawptr { + return msgSend(rawptr, self, "constantDataAtIndex:", index) +} +@(objc_type=ArgumentEncoder, objc_name="device") +ArgumentEncoder_device :: proc(self: ^ArgumentEncoder) -> ^ArgumentEncoder { + return msgSend(^ArgumentEncoder, self, "device") +} +@(objc_type=ArgumentEncoder, objc_name="encodedLength") +ArgumentEncoder_encodedLength :: proc(self: ^ArgumentEncoder) -> NS.Integer { + return msgSend(NS.Integer, self, "encodedLength") +} +@(objc_type=ArgumentEncoder, objc_name="label") +ArgumentEncoder_label :: proc(self: ^ArgumentEncoder) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=ArgumentEncoder, objc_name="newArgumentEncoderForBufferAtIndex") +ArgumentEncoder_newArgumentEncoderForBufferAtIndex :: proc(self: ^ArgumentEncoder, index: ^NS.Object) -> ^ArgumentEncoder { + return msgSend(^ArgumentEncoder, self, "newArgumentEncoderForBufferAtIndex:", index) +} +@(objc_type=ArgumentEncoder, objc_name="setAccelerationStructure") +ArgumentEncoder_setAccelerationStructure :: proc(self: ^ArgumentEncoder, accelerationStructure: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setAccelerationStructure:atIndex:", accelerationStructure, index) +} +@(objc_type=ArgumentEncoder, objc_name="setArgumentBuffer_offset_") +ArgumentEncoder_setArgumentBuffer_offset_ :: proc(self: ^ArgumentEncoder, argumentBuffer: ^NS.Object, offset: ^NS.Object) { + msgSend(nil, self, "setArgumentBuffer:offset:", argumentBuffer, offset) +} +@(objc_type=ArgumentEncoder, objc_name="setArgumentBuffer_startOffset_arrayElement_") +ArgumentEncoder_setArgumentBuffer_startOffset_arrayElement_ :: proc(self: ^ArgumentEncoder, argumentBuffer: ^NS.Object, startOffset: ^NS.Object, arrayElement: ^NS.Object) { + msgSend(nil, self, "setArgumentBuffer:startOffset:arrayElement:", argumentBuffer, startOffset, arrayElement) +} +@(objc_type=ArgumentEncoder, objc_name="setBuffer") +ArgumentEncoder_setBuffer :: proc(self: ^ArgumentEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setBuffer:offset:atIndex:", buffer, offset, index) +} +@(objc_type=ArgumentEncoder, objc_name="setBuffers") +ArgumentEncoder_setBuffers :: proc(self: ^ArgumentEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { + msgSend(nil, self, "setBuffers:offsets:withRange:", buffers, offsets, range) +} +@(objc_type=ArgumentEncoder, objc_name="setComputePipelineState") +ArgumentEncoder_setComputePipelineState :: proc(self: ^ArgumentEncoder, pipeline: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setComputePipelineState:atIndex:", pipeline, index) +} +@(objc_type=ArgumentEncoder, objc_name="setComputePipelineStates") +ArgumentEncoder_setComputePipelineStates :: proc(self: ^ArgumentEncoder, pipelines: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setComputePipelineStates:withRange:", pipelines, range) +} +@(objc_type=ArgumentEncoder, objc_name="setIndirectCommandBuffer") +ArgumentEncoder_setIndirectCommandBuffer :: proc(self: ^ArgumentEncoder, indirectCommandBuffer: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setIndirectCommandBuffer:atIndex:", indirectCommandBuffer, index) +} +@(objc_type=ArgumentEncoder, objc_name="setIndirectCommandBuffers") +ArgumentEncoder_setIndirectCommandBuffers :: proc(self: ^ArgumentEncoder, buffers: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setIndirectCommandBuffers:withRange:", buffers, range) +} +@(objc_type=ArgumentEncoder, objc_name="setIntersectionFunctionTable") +ArgumentEncoder_setIntersectionFunctionTable :: proc(self: ^ArgumentEncoder, intersectionFunctionTable: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setIntersectionFunctionTable:atIndex:", intersectionFunctionTable, index) +} +@(objc_type=ArgumentEncoder, objc_name="setIntersectionFunctionTables") +ArgumentEncoder_setIntersectionFunctionTables :: proc(self: ^ArgumentEncoder, intersectionFunctionTables: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setIntersectionFunctionTables:withRange:", intersectionFunctionTables, range) +} +@(objc_type=ArgumentEncoder, objc_name="setLabel") +ArgumentEncoder_setLabel :: proc(self: ^ArgumentEncoder, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} +@(objc_type=ArgumentEncoder, objc_name="setRenderPipelineState") +ArgumentEncoder_setRenderPipelineState :: proc(self: ^ArgumentEncoder, pipeline: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setRenderPipelineState:atIndex:", pipeline, index) +} +@(objc_type=ArgumentEncoder, objc_name="setRenderPipelineStates") +ArgumentEncoder_setRenderPipelineStates :: proc(self: ^ArgumentEncoder, pipelines: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setRenderPipelineStates:withRange:", pipelines, range) +} +@(objc_type=ArgumentEncoder, objc_name="setSamplerState") +ArgumentEncoder_setSamplerState :: proc(self: ^ArgumentEncoder, sampler: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setSamplerState:atIndex:", sampler, index) +} +@(objc_type=ArgumentEncoder, objc_name="setSamplerStates") +ArgumentEncoder_setSamplerStates :: proc(self: ^ArgumentEncoder, samplers: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setSamplerStates:withRange:", samplers, range) +} +@(objc_type=ArgumentEncoder, objc_name="setTexture") +ArgumentEncoder_setTexture :: proc(self: ^ArgumentEncoder, texture: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setTexture:atIndex:", texture, index) +} +@(objc_type=ArgumentEncoder, objc_name="setTextures") +ArgumentEncoder_setTextures :: proc(self: ^ArgumentEncoder, textures: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setTextures:withRange:", textures, range) +} +@(objc_type=ArgumentEncoder, objc_name="setVisibleFunctionTable") +ArgumentEncoder_setVisibleFunctionTable :: proc(self: ^ArgumentEncoder, visibleFunctionTable: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setVisibleFunctionTable:atIndex:", visibleFunctionTable, index) +} +@(objc_type=ArgumentEncoder, objc_name="setVisibleFunctionTables") +ArgumentEncoder_setVisibleFunctionTables :: proc(self: ^ArgumentEncoder, visibleFunctionTables: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setVisibleFunctionTables:withRange:", visibleFunctionTables, range) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + BinaryArchive +Class Methods: +Methods: + addComputePipelineFunctionsWithDescriptor + addRenderPipelineFunctionsWithDescriptor + addTileRenderPipelineFunctionsWithDescriptor + device + label + serializeToURL + setLabel +*/ +@(objc_class="MTLBinaryArchive") +BinaryArchive :: struct { using _: NS.Copying(BinaryArchive) } + +@(objc_type=BinaryArchive, objc_name="addComputePipelineFunctionsWithDescriptor") +BinaryArchive_addComputePipelineFunctionsWithDescriptor :: proc(self: ^BinaryArchive, descriptor: ^ComputePipelineDescriptor, error: ^^NS.Error ) -> BOOL { + return msgSend(BOOL, self, "addComputePipelineFunctionsWithDescriptor:error:", descriptor, error) +} +@(objc_type=BinaryArchive, objc_name="addRenderPipelineFunctionsWithDescriptor") +BinaryArchive_addRenderPipelineFunctionsWithDescriptor :: proc(self: ^BinaryArchive, descriptor: ^RenderPipelineDescriptor, error: ^^NS.Error ) -> BOOL { + return msgSend(BOOL, self, "addRenderPipelineFunctionsWithDescriptor:error:", descriptor, error) +} +@(objc_type=BinaryArchive, objc_name="addTileRenderPipelineFunctionsWithDescriptor") +BinaryArchive_addTileRenderPipelineFunctionsWithDescriptor :: proc(self: ^BinaryArchive, descriptor: ^TileRenderPipelineDescriptor, error: ^^NS.Error ) -> BOOL { + return msgSend(BOOL, self, "addTileRenderPipelineFunctionsWithDescriptor:error:", descriptor, error) +} +@(objc_type=BinaryArchive, objc_name="device") +BinaryArchive_device :: proc(self: ^BinaryArchive) -> ^BinaryArchive { + return msgSend(^BinaryArchive, self, "device") +} +@(objc_type=BinaryArchive, objc_name="label") +BinaryArchive_label :: proc(self: ^BinaryArchive) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=BinaryArchive, objc_name="serializeToURL") +BinaryArchive_serializeToURL :: proc(self: ^BinaryArchive, url: ^NS.URL, error: ^^NS.Error ) -> BOOL { + return msgSend(BOOL, self, "serializeToURL:error:", url, error) +} +@(objc_type=BinaryArchive, objc_name="setLabel") +BinaryArchive_setLabel :: proc(self: ^BinaryArchive, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + BlitCommandEncoder +Class Methods: +Methods: + copyFromBuffer + copyFromBuffer + copyFromBuffer + copyFromTexture + copyFromTexture + copyFromTexture + copyFromTexture + copyFromTexture + copyIndirectCommandBuffer + fillBuffer + generateMipmapsForTexture + getTextureAccessCounters + optimizeContentsForCPUAccess + optimizeContentsForCPUAccess + optimizeContentsForGPUAccess + optimizeContentsForGPUAccess + optimizeIndirectCommandBuffer + resetCommandsInBuffer + resetTextureAccessCounters + resolveCounters + sampleCountersInBuffer + synchronizeResource + synchronizeTexture + updateFence + waitForFence +*/ +@(objc_class="MTLBlitCommandEncoder") +BlitCommandEncoder :: struct { using _: NS.Object } + +@(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_") +BlitCommandEncoder_copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_ :: proc(self: ^BlitCommandEncoder, sourceBuffer: ^NS.Object, sourceOffset: ^NS.Object, sourceBytesPerRow: ^NS.Object, sourceBytesPerImage: ^NS.Object, sourceSize: Size, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, destinationOrigin: Origin) { + msgSend(nil, self, "copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:", sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin) +} +@(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_") +BlitCommandEncoder_copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_ :: proc(self: ^BlitCommandEncoder, sourceBuffer: ^NS.Object, sourceOffset: ^NS.Object, sourceBytesPerRow: ^NS.Object, sourceBytesPerImage: ^NS.Object, sourceSize: Size, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, destinationOrigin: Origin, options: BlitOption) { + msgSend(nil, self, "copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:options:", sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin, options) +} +@(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_") +BlitCommandEncoder_copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_ :: proc(self: ^BlitCommandEncoder, sourceBuffer: ^NS.Object, sourceOffset: ^NS.Object, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object, size: ^NS.Object) { + msgSend(nil, self, "copyFromBuffer:sourceOffset:toBuffer:destinationOffset:size:", sourceBuffer, sourceOffset, destinationBuffer, destinationOffset, size) +} +@(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_") +BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_ :: proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object, destinationBytesPerRow: ^NS.Object, destinationBytesPerImage: ^NS.Object) { + msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:", sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage) +} +@(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_") +BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_ :: proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object, destinationBytesPerRow: ^NS.Object, destinationBytesPerImage: ^NS.Object, options: BlitOption) { + msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:options:", sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage, options) +} +@(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_") +BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_ :: proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, sourceOrigin: Origin, sourceSize: Size, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, destinationOrigin: Origin) { + msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:", sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin) +} +@(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_") +BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_ :: proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, sliceCount: ^NS.Object, levelCount: ^NS.Object) { + msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:toTexture:destinationSlice:destinationLevel:sliceCount:levelCount:", sourceTexture, sourceSlice, sourceLevel, destinationTexture, destinationSlice, destinationLevel, sliceCount, levelCount) +} +@(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_toTexture_") +BlitCommandEncoder_copyFromTexture_toTexture_ :: proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, destinationTexture: ^NS.Object) { + msgSend(nil, self, "copyFromTexture:toTexture:", sourceTexture, destinationTexture) +} +@(objc_type=BlitCommandEncoder, objc_name="copyIndirectCommandBuffer") +BlitCommandEncoder_copyIndirectCommandBuffer :: proc(self: ^BlitCommandEncoder, source: ^NS.Object, sourceRange: NS.Range, destination: ^NS.Object, destinationIndex: ^NS.Object) { + msgSend(nil, self, "copyIndirectCommandBuffer:sourceRange:destination:destinationIndex:", source, sourceRange, destination, destinationIndex) +} +@(objc_type=BlitCommandEncoder, objc_name="fillBuffer") +BlitCommandEncoder_fillBuffer :: proc(self: ^BlitCommandEncoder, buffer: ^NS.Object, range: NS.Range, value: u8) { + msgSend(nil, self, "fillBuffer:range:value:", buffer, range, value) +} +@(objc_type=BlitCommandEncoder, objc_name="generateMipmapsForTexture") +BlitCommandEncoder_generateMipmapsForTexture :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object) { + msgSend(nil, self, "generateMipmapsForTexture:", texture) +} +@(objc_type=BlitCommandEncoder, objc_name="getTextureAccessCounters") +BlitCommandEncoder_getTextureAccessCounters :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object, region: Region, mipLevel: ^NS.Object, slice: ^NS.Object, resetCounters: BOOL, countersBuffer: ^NS.Object, countersBufferOffset: ^NS.Object) { + msgSend(nil, self, "getTextureAccessCounters:region:mipLevel:slice:resetCounters:countersBuffer:countersBufferOffset:", texture, region, mipLevel, slice, resetCounters, countersBuffer, countersBufferOffset) +} +@(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForCPUAccess") +BlitCommandEncoder_optimizeContentsForCPUAccess :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object) { + msgSend(nil, self, "optimizeContentsForCPUAccess:", texture) +} +@(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForCPUAccess_slice_level_") +BlitCommandEncoder_optimizeContentsForCPUAccess_slice_level_ :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object, slice: ^NS.Object, level: ^NS.Object) { + msgSend(nil, self, "optimizeContentsForCPUAccess:slice:level:", texture, slice, level) +} +@(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForGPUAccess") +BlitCommandEncoder_optimizeContentsForGPUAccess :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object) { + msgSend(nil, self, "optimizeContentsForGPUAccess:", texture) +} +@(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForGPUAccess_slice_level_") +BlitCommandEncoder_optimizeContentsForGPUAccess_slice_level_ :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object, slice: ^NS.Object, level: ^NS.Object) { + msgSend(nil, self, "optimizeContentsForGPUAccess:slice:level:", texture, slice, level) +} +@(objc_type=BlitCommandEncoder, objc_name="optimizeIndirectCommandBuffer") +BlitCommandEncoder_optimizeIndirectCommandBuffer :: proc(self: ^BlitCommandEncoder, indirectCommandBuffer: ^NS.Object, range: NS.Range) { + msgSend(nil, self, "optimizeIndirectCommandBuffer:withRange:", indirectCommandBuffer, range) +} +@(objc_type=BlitCommandEncoder, objc_name="resetCommandsInBuffer") +BlitCommandEncoder_resetCommandsInBuffer :: proc(self: ^BlitCommandEncoder, buffer: ^NS.Object, range: NS.Range) { + msgSend(nil, self, "resetCommandsInBuffer:withRange:", buffer, range) +} +@(objc_type=BlitCommandEncoder, objc_name="resetTextureAccessCounters") +BlitCommandEncoder_resetTextureAccessCounters :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object, region: Region, mipLevel: ^NS.Object, slice: ^NS.Object) { + msgSend(nil, self, "resetTextureAccessCounters:region:mipLevel:slice:", texture, region, mipLevel, slice) +} +@(objc_type=BlitCommandEncoder, objc_name="resolveCounters") +BlitCommandEncoder_resolveCounters :: proc(self: ^BlitCommandEncoder, sampleBuffer: ^NS.Object, range: NS.Range, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object) { + msgSend(nil, self, "resolveCounters:inRange:destinationBuffer:destinationOffset:", sampleBuffer, range, destinationBuffer, destinationOffset) +} +@(objc_type=BlitCommandEncoder, objc_name="sampleCountersInBuffer") +BlitCommandEncoder_sampleCountersInBuffer :: proc(self: ^BlitCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) { + msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier) +} +@(objc_type=BlitCommandEncoder, objc_name="synchronizeResource") +BlitCommandEncoder_synchronizeResource :: proc(self: ^BlitCommandEncoder, resource: ^NS.Object) { + msgSend(nil, self, "synchronizeResource:", resource) +} +@(objc_type=BlitCommandEncoder, objc_name="synchronizeTexture") +BlitCommandEncoder_synchronizeTexture :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object, slice: ^NS.Object, level: ^NS.Object) { + msgSend(nil, self, "synchronizeTexture:slice:level:", texture, slice, level) +} +@(objc_type=BlitCommandEncoder, objc_name="updateFence") +BlitCommandEncoder_updateFence :: proc(self: ^BlitCommandEncoder, fence: ^NS.Object) { + msgSend(nil, self, "updateFence:", fence) +} +@(objc_type=BlitCommandEncoder, objc_name="waitForFence") +BlitCommandEncoder_waitForFence :: proc(self: ^BlitCommandEncoder, fence: ^NS.Object) { + msgSend(nil, self, "waitForFence:", fence) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + Buffer +Class Methods: +Methods: + addDebugMarker + contents + didModifyRange + length + newRemoteBufferViewForDevice + newTextureWithDescriptor + remoteStorageBuffer + removeAllDebugMarkers +*/ +@(objc_class="MTLBuffer") +Buffer :: struct { using _: NS.Object } + +@(objc_type=Buffer, objc_name="addDebugMarker") +Buffer_addDebugMarker :: proc(self: ^Buffer, marker: ^NS.String, range: NS.Range) { + msgSend(nil, self, "addDebugMarker:range:", marker, range) +} +@(objc_type=Buffer, objc_name="contents") +Buffer_contents :: proc(self: ^Buffer) -> rawptr { + return msgSend(rawptr, self, "contents") +} +@(objc_type=Buffer, objc_name="didModifyRange") +Buffer_didModifyRange :: proc(self: ^Buffer, range: NS.Range) { + msgSend(nil, self, "didModifyRange:", range) +} +@(objc_type=Buffer, objc_name="length") +Buffer_length :: proc(self: ^Buffer) -> NS.Integer { + return msgSend(NS.Integer, self, "length") +} +@(objc_type=Buffer, objc_name="newRemoteBufferViewForDevice") +Buffer_newRemoteBufferViewForDevice :: proc(self: ^Buffer, device: ^NS.Object) -> ^Buffer { + return msgSend(^Buffer, self, "newRemoteBufferViewForDevice:", device) +} +@(objc_type=Buffer, objc_name="newTextureWithDescriptor") +Buffer_newTextureWithDescriptor :: proc(self: ^Buffer, descriptor: ^TextureDescriptor, offset: ^NS.Object, bytesPerRow: ^NS.Object) -> ^Buffer { + return msgSend(^Buffer, self, "newTextureWithDescriptor:offset:bytesPerRow:", descriptor, offset, bytesPerRow) +} +@(objc_type=Buffer, objc_name="remoteStorageBuffer") +Buffer_remoteStorageBuffer :: proc(self: ^Buffer) -> ^Buffer { + return msgSend(^Buffer, self, "remoteStorageBuffer") +} +@(objc_type=Buffer, objc_name="removeAllDebugMarkers") +Buffer_removeAllDebugMarkers :: proc(self: ^Buffer) { + msgSend(nil, self, "removeAllDebugMarkers") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + CaptureScope +Class Methods: +Methods: + beginScope + commandQueue + device + endScope + label + setLabel +*/ +@(objc_class="MTLCaptureScope") +CaptureScope :: struct { using _: NS.Object } + +@(objc_type=CaptureScope, objc_name="beginScope") +CaptureScope_beginScope :: proc(self: ^CaptureScope) { + msgSend(nil, self, "beginScope") +} +@(objc_type=CaptureScope, objc_name="commandQueue") +CaptureScope_commandQueue :: proc(self: ^CaptureScope) -> ^CaptureScope { + return msgSend(^CaptureScope, self, "commandQueue") +} +@(objc_type=CaptureScope, objc_name="device") +CaptureScope_device :: proc(self: ^CaptureScope) -> ^CaptureScope { + return msgSend(^CaptureScope, self, "device") +} +@(objc_type=CaptureScope, objc_name="endScope") +CaptureScope_endScope :: proc(self: ^CaptureScope) { + msgSend(nil, self, "endScope") +} +@(objc_type=CaptureScope, objc_name="label") +CaptureScope_label :: proc(self: ^CaptureScope) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=CaptureScope, objc_name="setLabel") +CaptureScope_setLabel :: proc(self: ^CaptureScope, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + CommandBuffer +Class Methods: +Methods: + GPUEndTime + GPUStartTime + accelerationStructureCommandEncoder + addCompletedHandler + addScheduledHandler + blitCommandEncoder + blitCommandEncoderWithDescriptor + commandQueue + commit + computeCommandEncoder + computeCommandEncoderWithDescriptor + computeCommandEncoderWithDispatchType + device + encodeSignalEvent + encodeWaitForEvent + enqueue + error + errorOptions + kernelEndTime + kernelStartTime + label + logs + parallelRenderCommandEncoderWithDescriptor + popDebugGroup + presentDrawable + presentDrawable + presentDrawable + pushDebugGroup + renderCommandEncoderWithDescriptor + resourceStateCommandEncoder + resourceStateCommandEncoderWithDescriptor + retainedReferences + setLabel + status + waitUntilCompleted + waitUntilScheduled +*/ +@(objc_class="MTLCommandBuffer") +CommandBuffer :: struct { using _: NS.Object } + +@(objc_type=CommandBuffer, objc_name="GPUEndTime") +CommandBuffer_GPUEndTime :: proc(self: ^CommandBuffer) -> CFTimeInterval { + return msgSend(CFTimeInterval, self, "GPUEndTime") +} +@(objc_type=CommandBuffer, objc_name="GPUStartTime") +CommandBuffer_GPUStartTime :: proc(self: ^CommandBuffer) -> CFTimeInterval { + return msgSend(CFTimeInterval, self, "GPUStartTime") +} +@(objc_type=CommandBuffer, objc_name="accelerationStructureCommandEncoder") +CommandBuffer_accelerationStructureCommandEncoder :: proc(self: ^CommandBuffer) -> ^CommandBuffer { + return msgSend(^CommandBuffer, self, "accelerationStructureCommandEncoder") +} +@(objc_type=CommandBuffer, objc_name="addCompletedHandler") +CommandBuffer_addCompletedHandler :: proc(self: ^CommandBuffer, block: CommandBufferHandler) { + msgSend(nil, self, "addCompletedHandler:", block) +} +@(objc_type=CommandBuffer, objc_name="addScheduledHandler") +CommandBuffer_addScheduledHandler :: proc(self: ^CommandBuffer, block: CommandBufferHandler) { + msgSend(nil, self, "addScheduledHandler:", block) +} +@(objc_type=CommandBuffer, objc_name="blitCommandEncoder") +CommandBuffer_blitCommandEncoder :: proc(self: ^CommandBuffer) -> ^CommandBuffer { + return msgSend(^CommandBuffer, self, "blitCommandEncoder") +} +@(objc_type=CommandBuffer, objc_name="blitCommandEncoderWithDescriptor") +CommandBuffer_blitCommandEncoderWithDescriptor :: proc(self: ^CommandBuffer, blitPassDescriptor: ^BlitPassDescriptor) -> ^CommandBuffer { + return msgSend(^CommandBuffer, self, "blitCommandEncoderWithDescriptor:", blitPassDescriptor) +} +@(objc_type=CommandBuffer, objc_name="commandQueue") +CommandBuffer_commandQueue :: proc(self: ^CommandBuffer) -> ^CommandBuffer { + return msgSend(^CommandBuffer, self, "commandQueue") +} +@(objc_type=CommandBuffer, objc_name="commit") +CommandBuffer_commit :: proc(self: ^CommandBuffer) { + msgSend(nil, self, "commit") +} +@(objc_type=CommandBuffer, objc_name="computeCommandEncoder") +CommandBuffer_computeCommandEncoder :: proc(self: ^CommandBuffer) -> ^CommandBuffer { + return msgSend(^CommandBuffer, self, "computeCommandEncoder") +} +@(objc_type=CommandBuffer, objc_name="computeCommandEncoderWithDescriptor") +CommandBuffer_computeCommandEncoderWithDescriptor :: proc(self: ^CommandBuffer, computePassDescriptor: ^ComputePassDescriptor) -> ^CommandBuffer { + return msgSend(^CommandBuffer, self, "computeCommandEncoderWithDescriptor:", computePassDescriptor) +} +@(objc_type=CommandBuffer, objc_name="computeCommandEncoderWithDispatchType") +CommandBuffer_computeCommandEncoderWithDispatchType :: proc(self: ^CommandBuffer, dispatchType: DispatchType) -> ^CommandBuffer { + return msgSend(^CommandBuffer, self, "computeCommandEncoderWithDispatchType:", dispatchType) +} +@(objc_type=CommandBuffer, objc_name="device") +CommandBuffer_device :: proc(self: ^CommandBuffer) -> ^CommandBuffer { + return msgSend(^CommandBuffer, self, "device") +} +@(objc_type=CommandBuffer, objc_name="encodeSignalEvent") +CommandBuffer_encodeSignalEvent :: proc(self: ^CommandBuffer, event: ^NS.Object, value: u64) { + msgSend(nil, self, "encodeSignalEvent:value:", event, value) +} +@(objc_type=CommandBuffer, objc_name="encodeWaitForEvent") +CommandBuffer_encodeWaitForEvent :: proc(self: ^CommandBuffer, event: ^NS.Object, value: u64) { + msgSend(nil, self, "encodeWaitForEvent:value:", event, value) +} +@(objc_type=CommandBuffer, objc_name="enqueue") +CommandBuffer_enqueue :: proc(self: ^CommandBuffer) { + msgSend(nil, self, "enqueue") +} +@(objc_type=CommandBuffer, objc_name="error") +CommandBuffer_error :: proc(self: ^CommandBuffer) -> ^NS.Error { + return msgSend(^NS.Error, self, "error") +} +@(objc_type=CommandBuffer, objc_name="errorOptions") +CommandBuffer_errorOptions :: proc(self: ^CommandBuffer) -> CommandBufferErrorOption { + return msgSend(CommandBufferErrorOption, self, "errorOptions") +} +@(objc_type=CommandBuffer, objc_name="kernelEndTime") +CommandBuffer_kernelEndTime :: proc(self: ^CommandBuffer) -> CFTimeInterval { + return msgSend(CFTimeInterval, self, "kernelEndTime") +} +@(objc_type=CommandBuffer, objc_name="kernelStartTime") +CommandBuffer_kernelStartTime :: proc(self: ^CommandBuffer) -> CFTimeInterval { + return msgSend(CFTimeInterval, self, "kernelStartTime") +} +@(objc_type=CommandBuffer, objc_name="label") +CommandBuffer_label :: proc(self: ^CommandBuffer) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=CommandBuffer, objc_name="logs") +CommandBuffer_logs :: proc(self: ^CommandBuffer) -> ^CommandBuffer { + return msgSend(^CommandBuffer, self, "logs") +} +@(objc_type=CommandBuffer, objc_name="parallelRenderCommandEncoderWithDescriptor") +CommandBuffer_parallelRenderCommandEncoderWithDescriptor :: proc(self: ^CommandBuffer, renderPassDescriptor: ^RenderPassDescriptor) -> ^CommandBuffer { + return msgSend(^CommandBuffer, self, "parallelRenderCommandEncoderWithDescriptor:", renderPassDescriptor) +} +@(objc_type=CommandBuffer, objc_name="popDebugGroup") +CommandBuffer_popDebugGroup :: proc(self: ^CommandBuffer) { + msgSend(nil, self, "popDebugGroup") +} +@(objc_type=CommandBuffer, objc_name="presentDrawable") +CommandBuffer_presentDrawable :: proc(self: ^CommandBuffer, drawable: ^NS.Object) { + msgSend(nil, self, "presentDrawable:", drawable) +} +@(objc_type=CommandBuffer, objc_name="presentDrawable_afterMinimumDuration_") +CommandBuffer_presentDrawable_afterMinimumDuration_ :: proc(self: ^CommandBuffer, drawable: ^NS.Object, duration: CFTimeInterval) { + msgSend(nil, self, "presentDrawable:afterMinimumDuration:", drawable, duration) +} +@(objc_type=CommandBuffer, objc_name="presentDrawable_atTime_") +CommandBuffer_presentDrawable_atTime_ :: proc(self: ^CommandBuffer, drawable: ^NS.Object, presentationTime: CFTimeInterval) { + msgSend(nil, self, "presentDrawable:atTime:", drawable, presentationTime) +} +@(objc_type=CommandBuffer, objc_name="pushDebugGroup") +CommandBuffer_pushDebugGroup :: proc(self: ^CommandBuffer, string: ^NS.String) { + msgSend(nil, self, "pushDebugGroup:", string) +} +@(objc_type=CommandBuffer, objc_name="renderCommandEncoderWithDescriptor") +CommandBuffer_renderCommandEncoderWithDescriptor :: proc(self: ^CommandBuffer, renderPassDescriptor: ^RenderPassDescriptor) -> ^CommandBuffer { + return msgSend(^CommandBuffer, self, "renderCommandEncoderWithDescriptor:", renderPassDescriptor) +} +@(objc_type=CommandBuffer, objc_name="resourceStateCommandEncoder") +CommandBuffer_resourceStateCommandEncoder :: proc(self: ^CommandBuffer) -> ^CommandBuffer { + return msgSend(^CommandBuffer, self, "resourceStateCommandEncoder") +} +@(objc_type=CommandBuffer, objc_name="resourceStateCommandEncoderWithDescriptor") +CommandBuffer_resourceStateCommandEncoderWithDescriptor :: proc(self: ^CommandBuffer, resourceStatePassDescriptor: ^ResourceStatePassDescriptor) -> ^CommandBuffer { + return msgSend(^CommandBuffer, self, "resourceStateCommandEncoderWithDescriptor:", resourceStatePassDescriptor) +} +@(objc_type=CommandBuffer, objc_name="retainedReferences") +CommandBuffer_retainedReferences :: proc(self: ^CommandBuffer) -> BOOL { + return msgSend(BOOL, self, "retainedReferences") +} +@(objc_type=CommandBuffer, objc_name="setLabel") +CommandBuffer_setLabel :: proc(self: ^CommandBuffer, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} +@(objc_type=CommandBuffer, objc_name="status") +CommandBuffer_status :: proc(self: ^CommandBuffer) -> CommandBufferStatus { + return msgSend(CommandBufferStatus, self, "status") +} +@(objc_type=CommandBuffer, objc_name="waitUntilCompleted") +CommandBuffer_waitUntilCompleted :: proc(self: ^CommandBuffer) { + msgSend(nil, self, "waitUntilCompleted") +} +@(objc_type=CommandBuffer, objc_name="waitUntilScheduled") +CommandBuffer_waitUntilScheduled :: proc(self: ^CommandBuffer) { + msgSend(nil, self, "waitUntilScheduled") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + CommandBufferEncoderInfo +Class Methods: +Methods: + debugSignposts + errorState + label +*/ +@(objc_class="MTLCommandBufferEncoderInfo") +CommandBufferEncoderInfo :: struct { using _: NS.Object } + +@(objc_type=CommandBufferEncoderInfo, objc_name="debugSignposts") +CommandBufferEncoderInfo_debugSignposts :: proc(self: ^CommandBufferEncoderInfo) -> ^NS.Array { + return msgSend(^NS.Array, self, "debugSignposts") +} +@(objc_type=CommandBufferEncoderInfo, objc_name="errorState") +CommandBufferEncoderInfo_errorState :: proc(self: ^CommandBufferEncoderInfo) -> CommandEncoderErrorState { + return msgSend(CommandEncoderErrorState, self, "errorState") +} +@(objc_type=CommandBufferEncoderInfo, objc_name="label") +CommandBufferEncoderInfo_label :: proc(self: ^CommandBufferEncoderInfo) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + CommandEncoder +Class Methods: +Methods: + device + endEncoding + insertDebugSignpost + label + popDebugGroup + pushDebugGroup + setLabel +*/ +@(objc_class="MTLCommandEncoder") +CommandEncoder :: struct { using _: NS.Object } + +@(objc_type=CommandEncoder, objc_name="device") +CommandEncoder_device :: proc(self: ^CommandEncoder) -> ^CommandEncoder { + return msgSend(^CommandEncoder, self, "device") +} +@(objc_type=CommandEncoder, objc_name="endEncoding") +CommandEncoder_endEncoding :: proc(self: ^CommandEncoder) { + msgSend(nil, self, "endEncoding") +} +@(objc_type=CommandEncoder, objc_name="insertDebugSignpost") +CommandEncoder_insertDebugSignpost :: proc(self: ^CommandEncoder, string: ^NS.String) { + msgSend(nil, self, "insertDebugSignpost:", string) +} +@(objc_type=CommandEncoder, objc_name="label") +CommandEncoder_label :: proc(self: ^CommandEncoder) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=CommandEncoder, objc_name="popDebugGroup") +CommandEncoder_popDebugGroup :: proc(self: ^CommandEncoder) { + msgSend(nil, self, "popDebugGroup") +} +@(objc_type=CommandEncoder, objc_name="pushDebugGroup") +CommandEncoder_pushDebugGroup :: proc(self: ^CommandEncoder, string: ^NS.String) { + msgSend(nil, self, "pushDebugGroup:", string) +} +@(objc_type=CommandEncoder, objc_name="setLabel") +CommandEncoder_setLabel :: proc(self: ^CommandEncoder, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + CommandQueue +Class Methods: +Methods: + commandBuffer + commandBufferWithDescriptor + commandBufferWithUnretainedReferences + device + insertDebugCaptureBoundary + label + setLabel +*/ +@(objc_class="MTLCommandQueue") +CommandQueue :: struct { using _: NS.Object } + +@(objc_type=CommandQueue, objc_name="commandBuffer") +CommandQueue_commandBuffer :: proc(self: ^CommandQueue) -> ^CommandQueue { + return msgSend(^CommandQueue, self, "commandBuffer") +} +@(objc_type=CommandQueue, objc_name="commandBufferWithDescriptor") +CommandQueue_commandBufferWithDescriptor :: proc(self: ^CommandQueue, descriptor: ^CommandBufferDescriptor) -> ^CommandQueue { + return msgSend(^CommandQueue, self, "commandBufferWithDescriptor:", descriptor) +} +@(objc_type=CommandQueue, objc_name="commandBufferWithUnretainedReferences") +CommandQueue_commandBufferWithUnretainedReferences :: proc(self: ^CommandQueue) -> ^CommandQueue { + return msgSend(^CommandQueue, self, "commandBufferWithUnretainedReferences") +} +@(objc_type=CommandQueue, objc_name="device") +CommandQueue_device :: proc(self: ^CommandQueue) -> ^CommandQueue { + return msgSend(^CommandQueue, self, "device") +} +@(objc_type=CommandQueue, objc_name="insertDebugCaptureBoundary") +CommandQueue_insertDebugCaptureBoundary :: proc(self: ^CommandQueue) { + msgSend(nil, self, "insertDebugCaptureBoundary") +} +@(objc_type=CommandQueue, objc_name="label") +CommandQueue_label :: proc(self: ^CommandQueue) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=CommandQueue, objc_name="setLabel") +CommandQueue_setLabel :: proc(self: ^CommandQueue, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + ComputeCommandEncoder +Class Methods: +Methods: + dispatchThreadgroups + dispatchThreadgroupsWithIndirectBuffer + dispatchThreads + dispatchType + executeCommandsInBuffer + executeCommandsInBuffer + memoryBarrierWithResources + memoryBarrierWithScope + sampleCountersInBuffer + setAccelerationStructure + setBuffer + setBufferOffset + setBuffers + setBytes + setComputePipelineState + setImageblockWidth + setIntersectionFunctionTable + setIntersectionFunctionTables + setSamplerState + setSamplerState + setSamplerStates + setSamplerStates + setStageInRegion + setStageInRegionWithIndirectBuffer + setTexture + setTextures + setThreadgroupMemoryLength + setVisibleFunctionTable + setVisibleFunctionTables + updateFence + useHeap + useHeaps + useResource + useResources + waitForFence +*/ +@(objc_class="MTLComputeCommandEncoder") +ComputeCommandEncoder :: struct { using _: NS.Object } + +@(objc_type=ComputeCommandEncoder, objc_name="dispatchThreadgroups") +ComputeCommandEncoder_dispatchThreadgroups :: proc(self: ^ComputeCommandEncoder, threadgroupsPerGrid: Size, threadsPerThreadgroup: Size) { + msgSend(nil, self, "dispatchThreadgroups:threadsPerThreadgroup:", threadgroupsPerGrid, threadsPerThreadgroup) +} +@(objc_type=ComputeCommandEncoder, objc_name="dispatchThreadgroupsWithIndirectBuffer") +ComputeCommandEncoder_dispatchThreadgroupsWithIndirectBuffer :: proc(self: ^ComputeCommandEncoder, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object, threadsPerThreadgroup: Size) { + msgSend(nil, self, "dispatchThreadgroupsWithIndirectBuffer:indirectBufferOffset:threadsPerThreadgroup:", indirectBuffer, indirectBufferOffset, threadsPerThreadgroup) +} +@(objc_type=ComputeCommandEncoder, objc_name="dispatchThreads") +ComputeCommandEncoder_dispatchThreads :: proc(self: ^ComputeCommandEncoder, threadsPerGrid: Size, threadsPerThreadgroup: Size) { + msgSend(nil, self, "dispatchThreads:threadsPerThreadgroup:", threadsPerGrid, threadsPerThreadgroup) +} +@(objc_type=ComputeCommandEncoder, objc_name="dispatchType") +ComputeCommandEncoder_dispatchType :: proc(self: ^ComputeCommandEncoder) -> DispatchType { + return msgSend(DispatchType, self, "dispatchType") +} +@(objc_type=ComputeCommandEncoder, objc_name="executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_") +ComputeCommandEncoder_executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_ :: proc(self: ^ComputeCommandEncoder, indirectCommandbuffer: ^NS.Object, indirectRangeBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { + msgSend(nil, self, "executeCommandsInBuffer:indirectBuffer:indirectBufferOffset:", indirectCommandbuffer, indirectRangeBuffer, indirectBufferOffset) +} +@(objc_type=ComputeCommandEncoder, objc_name="executeCommandsInBuffer_withRange_") +ComputeCommandEncoder_executeCommandsInBuffer_withRange_ :: proc(self: ^ComputeCommandEncoder, indirectCommandBuffer: ^NS.Object, executionRange: NS.Range) { + msgSend(nil, self, "executeCommandsInBuffer:withRange:", indirectCommandBuffer, executionRange) +} +@(objc_type=ComputeCommandEncoder, objc_name="memoryBarrierWithResources") +ComputeCommandEncoder_memoryBarrierWithResources :: proc(self: ^ComputeCommandEncoder, resources: ^^NS.Object, count: ^NS.Object) { + msgSend(nil, self, "memoryBarrierWithResources:count:", resources, count) +} +@(objc_type=ComputeCommandEncoder, objc_name="memoryBarrierWithScope") +ComputeCommandEncoder_memoryBarrierWithScope :: proc(self: ^ComputeCommandEncoder, scope: BarrierScope) { + msgSend(nil, self, "memoryBarrierWithScope:", scope) +} +@(objc_type=ComputeCommandEncoder, objc_name="sampleCountersInBuffer") +ComputeCommandEncoder_sampleCountersInBuffer :: proc(self: ^ComputeCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) { + msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier) +} +@(objc_type=ComputeCommandEncoder, objc_name="setAccelerationStructure") +ComputeCommandEncoder_setAccelerationStructure :: proc(self: ^ComputeCommandEncoder, accelerationStructure: ^NS.Object, bufferIndex: ^NS.Object) { + msgSend(nil, self, "setAccelerationStructure:atBufferIndex:", accelerationStructure, bufferIndex) +} +@(objc_type=ComputeCommandEncoder, objc_name="setBuffer") +ComputeCommandEncoder_setBuffer :: proc(self: ^ComputeCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setBuffer:offset:atIndex:", buffer, offset, index) +} +@(objc_type=ComputeCommandEncoder, objc_name="setBufferOffset") +ComputeCommandEncoder_setBufferOffset :: proc(self: ^ComputeCommandEncoder, offset: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setBufferOffset:atIndex:", offset, index) +} +@(objc_type=ComputeCommandEncoder, objc_name="setBuffers") +ComputeCommandEncoder_setBuffers :: proc(self: ^ComputeCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { + msgSend(nil, self, "setBuffers:offsets:withRange:", buffers, offsets, range) +} +@(objc_type=ComputeCommandEncoder, objc_name="setBytes") +ComputeCommandEncoder_setBytes :: proc(self: ^ComputeCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setBytes:length:atIndex:", bytes, length, index) +} +@(objc_type=ComputeCommandEncoder, objc_name="setComputePipelineState") +ComputeCommandEncoder_setComputePipelineState :: proc(self: ^ComputeCommandEncoder, pipelineState: ^NS.Object) { + msgSend(nil, self, "setComputePipelineState:", pipelineState) +} +@(objc_type=ComputeCommandEncoder, objc_name="setImageblockWidth") +ComputeCommandEncoder_setImageblockWidth :: proc(self: ^ComputeCommandEncoder, width: ^NS.Object, height: ^NS.Object) { + msgSend(nil, self, "setImageblockWidth:height:", width, height) +} +@(objc_type=ComputeCommandEncoder, objc_name="setIntersectionFunctionTable") +ComputeCommandEncoder_setIntersectionFunctionTable :: proc(self: ^ComputeCommandEncoder, intersectionFunctionTable: ^NS.Object, bufferIndex: ^NS.Object) { + msgSend(nil, self, "setIntersectionFunctionTable:atBufferIndex:", intersectionFunctionTable, bufferIndex) +} +@(objc_type=ComputeCommandEncoder, objc_name="setIntersectionFunctionTables") +ComputeCommandEncoder_setIntersectionFunctionTables :: proc(self: ^ComputeCommandEncoder, intersectionFunctionTables: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setIntersectionFunctionTables:withBufferRange:", intersectionFunctionTables, range) +} +@(objc_type=ComputeCommandEncoder, objc_name="setSamplerState_atIndex_") +ComputeCommandEncoder_setSamplerState_atIndex_ :: proc(self: ^ComputeCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setSamplerState:atIndex:", sampler, index) +} +@(objc_type=ComputeCommandEncoder, objc_name="setSamplerState_lodMinClamp_lodMaxClamp_atIndex_") +ComputeCommandEncoder_setSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: proc(self: ^ComputeCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) { + msgSend(nil, self, "setSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) +} +@(objc_type=ComputeCommandEncoder, objc_name="setSamplerStates_lodMinClamps_lodMaxClamps_withRange_") +ComputeCommandEncoder_setSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: proc(self: ^ComputeCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { + msgSend(nil, self, "setSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range) +} +@(objc_type=ComputeCommandEncoder, objc_name="setSamplerStates_withRange_") +ComputeCommandEncoder_setSamplerStates_withRange_ :: proc(self: ^ComputeCommandEncoder, samplers: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setSamplerStates:withRange:", samplers, range) +} +@(objc_type=ComputeCommandEncoder, objc_name="setStageInRegion") +ComputeCommandEncoder_setStageInRegion :: proc(self: ^ComputeCommandEncoder, region: Region) { + msgSend(nil, self, "setStageInRegion:", region) +} +@(objc_type=ComputeCommandEncoder, objc_name="setStageInRegionWithIndirectBuffer") +ComputeCommandEncoder_setStageInRegionWithIndirectBuffer :: proc(self: ^ComputeCommandEncoder, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { + msgSend(nil, self, "setStageInRegionWithIndirectBuffer:indirectBufferOffset:", indirectBuffer, indirectBufferOffset) +} +@(objc_type=ComputeCommandEncoder, objc_name="setTexture") +ComputeCommandEncoder_setTexture :: proc(self: ^ComputeCommandEncoder, texture: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setTexture:atIndex:", texture, index) +} +@(objc_type=ComputeCommandEncoder, objc_name="setTextures") +ComputeCommandEncoder_setTextures :: proc(self: ^ComputeCommandEncoder, textures: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setTextures:withRange:", textures, range) +} +@(objc_type=ComputeCommandEncoder, objc_name="setThreadgroupMemoryLength") +ComputeCommandEncoder_setThreadgroupMemoryLength :: proc(self: ^ComputeCommandEncoder, length: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setThreadgroupMemoryLength:atIndex:", length, index) +} +@(objc_type=ComputeCommandEncoder, objc_name="setVisibleFunctionTable") +ComputeCommandEncoder_setVisibleFunctionTable :: proc(self: ^ComputeCommandEncoder, visibleFunctionTable: ^NS.Object, bufferIndex: ^NS.Object) { + msgSend(nil, self, "setVisibleFunctionTable:atBufferIndex:", visibleFunctionTable, bufferIndex) +} +@(objc_type=ComputeCommandEncoder, objc_name="setVisibleFunctionTables") +ComputeCommandEncoder_setVisibleFunctionTables :: proc(self: ^ComputeCommandEncoder, visibleFunctionTables: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setVisibleFunctionTables:withBufferRange:", visibleFunctionTables, range) +} +@(objc_type=ComputeCommandEncoder, objc_name="updateFence") +ComputeCommandEncoder_updateFence :: proc(self: ^ComputeCommandEncoder, fence: ^NS.Object) { + msgSend(nil, self, "updateFence:", fence) +} +@(objc_type=ComputeCommandEncoder, objc_name="useHeap") +ComputeCommandEncoder_useHeap :: proc(self: ^ComputeCommandEncoder, heap: ^NS.Object) { + msgSend(nil, self, "useHeap:", heap) +} +@(objc_type=ComputeCommandEncoder, objc_name="useHeaps") +ComputeCommandEncoder_useHeaps :: proc(self: ^ComputeCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object) { + msgSend(nil, self, "useHeaps:count:", heaps, count) +} +@(objc_type=ComputeCommandEncoder, objc_name="useResource") +ComputeCommandEncoder_useResource :: proc(self: ^ComputeCommandEncoder, resource: ^NS.Object, usage: ResourceUsage) { + msgSend(nil, self, "useResource:usage:", resource, usage) +} +@(objc_type=ComputeCommandEncoder, objc_name="useResources") +ComputeCommandEncoder_useResources :: proc(self: ^ComputeCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage) { + msgSend(nil, self, "useResources:count:usage:", resources, count, usage) +} +@(objc_type=ComputeCommandEncoder, objc_name="waitForFence") +ComputeCommandEncoder_waitForFence :: proc(self: ^ComputeCommandEncoder, fence: ^NS.Object) { + msgSend(nil, self, "waitForFence:", fence) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + ComputePipelineState +Class Methods: +Methods: + device + functionHandleWithFunction + imageblockMemoryLengthForDimensions + label + maxTotalThreadsPerThreadgroup + newComputePipelineStateWithAdditionalBinaryFunctions + newIntersectionFunctionTableWithDescriptor + newVisibleFunctionTableWithDescriptor + staticThreadgroupMemoryLength + supportIndirectCommandBuffers + threadExecutionWidth +*/ +@(objc_class="MTLComputePipelineState") +ComputePipelineState :: struct { using _: NS.Object } + +@(objc_type=ComputePipelineState, objc_name="device") +ComputePipelineState_device :: proc(self: ^ComputePipelineState) -> ^ComputePipelineState { + return msgSend(^ComputePipelineState, self, "device") +} +@(objc_type=ComputePipelineState, objc_name="functionHandleWithFunction") +ComputePipelineState_functionHandleWithFunction :: proc(self: ^ComputePipelineState, function: ^NS.Object) -> ^ComputePipelineState { + return msgSend(^ComputePipelineState, self, "functionHandleWithFunction:", function) +} +@(objc_type=ComputePipelineState, objc_name="imageblockMemoryLengthForDimensions") +ComputePipelineState_imageblockMemoryLengthForDimensions :: proc(self: ^ComputePipelineState, imageblockDimensions: Size) -> ^ComputePipelineState { + return msgSend(^ComputePipelineState, self, "imageblockMemoryLengthForDimensions:", imageblockDimensions) +} +@(objc_type=ComputePipelineState, objc_name="label") +ComputePipelineState_label :: proc(self: ^ComputePipelineState) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=ComputePipelineState, objc_name="maxTotalThreadsPerThreadgroup") +ComputePipelineState_maxTotalThreadsPerThreadgroup :: proc(self: ^ComputePipelineState) -> NS.Integer { + return msgSend(NS.Integer, self, "maxTotalThreadsPerThreadgroup") +} +@(objc_type=ComputePipelineState, objc_name="newComputePipelineStateWithAdditionalBinaryFunctions") +ComputePipelineState_newComputePipelineStateWithAdditionalBinaryFunctions :: proc(self: ^ComputePipelineState, functions: ^NS.Array, error: ^^NS.Error ) -> ^ComputePipelineState { + return msgSend(^ComputePipelineState, self, "newComputePipelineStateWithAdditionalBinaryFunctions:error:", functions, error) +} +@(objc_type=ComputePipelineState, objc_name="newIntersectionFunctionTableWithDescriptor") +ComputePipelineState_newIntersectionFunctionTableWithDescriptor :: proc(self: ^ComputePipelineState, descriptor: ^IntersectionFunctionTableDescriptor) -> ^ComputePipelineState { + return msgSend(^ComputePipelineState, self, "newIntersectionFunctionTableWithDescriptor:", descriptor) +} +@(objc_type=ComputePipelineState, objc_name="newVisibleFunctionTableWithDescriptor") +ComputePipelineState_newVisibleFunctionTableWithDescriptor :: proc(self: ^ComputePipelineState, descriptor: ^VisibleFunctionTableDescriptor) -> ^ComputePipelineState { + return msgSend(^ComputePipelineState, self, "newVisibleFunctionTableWithDescriptor:", descriptor) +} +@(objc_type=ComputePipelineState, objc_name="staticThreadgroupMemoryLength") +ComputePipelineState_staticThreadgroupMemoryLength :: proc(self: ^ComputePipelineState) -> NS.Integer { + return msgSend(NS.Integer, self, "staticThreadgroupMemoryLength") +} +@(objc_type=ComputePipelineState, objc_name="supportIndirectCommandBuffers") +ComputePipelineState_supportIndirectCommandBuffers :: proc(self: ^ComputePipelineState) -> BOOL { + return msgSend(BOOL, self, "supportIndirectCommandBuffers") +} +@(objc_type=ComputePipelineState, objc_name="threadExecutionWidth") +ComputePipelineState_threadExecutionWidth :: proc(self: ^ComputePipelineState) -> NS.Integer { + return msgSend(NS.Integer, self, "threadExecutionWidth") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + Counter +Class Methods: +Methods: + name +*/ +@(objc_class="MTLCounter") +Counter :: struct { using _: NS.Object } + +@(objc_type=Counter, objc_name="name") +Counter_name :: proc(self: ^Counter) -> ^NS.String { + return msgSend(^NS.String, self, "name") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + CounterSampleBuffer +Class Methods: +Methods: + device + label + resolveCounterRange + sampleCount +*/ +@(objc_class="MTLCounterSampleBuffer") +CounterSampleBuffer :: struct { using _: NS.Object } + +@(objc_type=CounterSampleBuffer, objc_name="device") +CounterSampleBuffer_device :: proc(self: ^CounterSampleBuffer) -> ^CounterSampleBuffer { + return msgSend(^CounterSampleBuffer, self, "device") +} +@(objc_type=CounterSampleBuffer, objc_name="label") +CounterSampleBuffer_label :: proc(self: ^CounterSampleBuffer) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=CounterSampleBuffer, objc_name="resolveCounterRange") +CounterSampleBuffer_resolveCounterRange :: proc(self: ^CounterSampleBuffer, range: NS.Range) -> ^NS.Data { + return msgSend(^NS.Data, self, "resolveCounterRange:", range) +} +@(objc_type=CounterSampleBuffer, objc_name="sampleCount") +CounterSampleBuffer_sampleCount :: proc(self: ^CounterSampleBuffer) -> NS.Integer { + return msgSend(NS.Integer, self, "sampleCount") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + CounterSet +Class Methods: +Methods: + counters + name +*/ +@(objc_class="MTLCounterSet") +CounterSet :: struct { using _: NS.Object } + +@(objc_type=CounterSet, objc_name="counters") +CounterSet_counters :: proc(self: ^CounterSet) -> ^NS.Array { + return msgSend(^NS.Array, self, "counters") +} +@(objc_type=CounterSet, objc_name="name") +CounterSet_name :: proc(self: ^CounterSet) -> ^NS.String { + return msgSend(^NS.String, self, "name") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + DepthStencilState +Class Methods: +Methods: + device + label +*/ +@(objc_class="MTLDepthStencilState") +DepthStencilState :: struct { using _: NS.Object } + +@(objc_type=DepthStencilState, objc_name="device") +DepthStencilState_device :: proc(self: ^DepthStencilState) -> ^DepthStencilState { + return msgSend(^DepthStencilState, self, "device") +} +@(objc_type=DepthStencilState, objc_name="label") +DepthStencilState_label :: proc(self: ^DepthStencilState) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + Device +Class Methods: +Methods: + accelerationStructureSizesWithDescriptor + areBarycentricCoordsSupported + areProgrammableSamplePositionsSupported + areRasterOrderGroupsSupported + argumentBuffersSupport + convertSparsePixelRegions + convertSparseTileRegions + counterSets + currentAllocatedSize + getDefaultSamplePositions + hasUnifiedMemory + heapBufferSizeAndAlignWithLength + heapTextureSizeAndAlignWithDescriptor + isDepth24Stencil8PixelFormatSupported + isHeadless + isLowPower + isRemovable + location + locationNumber + maxArgumentBufferSamplerCount + maxBufferLength + maxThreadgroupMemoryLength + maxThreadsPerThreadgroup + maxTransferRate + minimumLinearTextureAlignmentForPixelFormat + minimumTextureBufferAlignmentForPixelFormat + name + newAccelerationStructureWithDescriptor + newAccelerationStructureWithSize + newArgumentEncoderWithArguments + newBinaryArchiveWithDescriptor + newBufferWithBytes + newBufferWithBytesNoCopy + newBufferWithLength + newCommandQueue + newCommandQueueWithMaxCommandBufferCount + newComputePipelineStateWithDescriptor + newComputePipelineStateWithDescriptor + newComputePipelineStateWithFunction + newComputePipelineStateWithFunction + newComputePipelineStateWithFunction + newComputePipelineStateWithFunction + newCounterSampleBufferWithDescriptor + newDefaultLibrary + newDefaultLibraryWithBundle + newDepthStencilStateWithDescriptor + newDynamicLibrary + newDynamicLibraryWithURL + newEvent + newFence + newHeapWithDescriptor + newIndirectCommandBufferWithDescriptor + newLibraryWithData + newLibraryWithFile + newLibraryWithSource + newLibraryWithSource + newLibraryWithURL + newRasterizationRateMapWithDescriptor + newRenderPipelineStateWithDescriptor + newRenderPipelineStateWithDescriptor + newRenderPipelineStateWithDescriptor + newRenderPipelineStateWithDescriptor + newRenderPipelineStateWithTileDescriptor + newRenderPipelineStateWithTileDescriptor + newSamplerStateWithDescriptor + newSharedEvent + newSharedEventWithHandle + newSharedTextureWithDescriptor + newSharedTextureWithHandle + newTextureWithDescriptor + newTextureWithDescriptor + peerCount + peerGroupID + peerIndex + readWriteTextureSupport + recommendedMaxWorkingSetSize + registryID + sampleTimestamps + sparseTileSizeInBytes + sparseTileSizeWithTextureType + supports32BitFloatFiltering + supports32BitMSAA + supportsBCTextureCompression + supportsCounterSampling + supportsDynamicLibraries + supportsFamily + supportsFeatureSet + supportsFunctionPointers + supportsPullModelInterpolation + supportsQueryTextureLOD + supportsRasterizationRateMapWithLayerCount + supportsRaytracing + supportsShaderBarycentricCoordinates + supportsTextureSampleCount + supportsVertexAmplificationCount +*/ +@(objc_class="MTLDevice") +Device :: struct { using _: NS.Object } + +@(objc_type=Device, objc_name="accelerationStructureSizesWithDescriptor") +Device_accelerationStructureSizesWithDescriptor :: proc(self: ^Device, descriptor: ^AccelerationStructureDescriptor) -> AccelerationStructureSizes { + return msgSend(AccelerationStructureSizes, self, "accelerationStructureSizesWithDescriptor:", descriptor) +} +@(objc_type=Device, objc_name="areBarycentricCoordsSupported") +Device_areBarycentricCoordsSupported :: proc(self: ^Device) -> BOOL { + return msgSend(BOOL, self, "areBarycentricCoordsSupported") +} +@(objc_type=Device, objc_name="areProgrammableSamplePositionsSupported") +Device_areProgrammableSamplePositionsSupported :: proc(self: ^Device) -> BOOL { + return msgSend(BOOL, self, "areProgrammableSamplePositionsSupported") +} +@(objc_type=Device, objc_name="areRasterOrderGroupsSupported") +Device_areRasterOrderGroupsSupported :: proc(self: ^Device) -> BOOL { + return msgSend(BOOL, self, "areRasterOrderGroupsSupported") +} +@(objc_type=Device, objc_name="argumentBuffersSupport") +Device_argumentBuffersSupport :: proc(self: ^Device) -> ArgumentBuffersTier { + return msgSend(ArgumentBuffersTier, self, "argumentBuffersSupport") +} +@(objc_type=Device, objc_name="convertSparsePixelRegions") +Device_convertSparsePixelRegions :: proc(self: ^Device, pixelRegions: ^Region, tileRegions: ^Region, tileSize: Size, mode: SparseTextureRegionAlignmentMode, numRegions: ^NS.Object) { + msgSend(nil, self, "convertSparsePixelRegions:toTileRegions:withTileSize:alignmentMode:numRegions:", pixelRegions, tileRegions, tileSize, mode, numRegions) +} +@(objc_type=Device, objc_name="convertSparseTileRegions") +Device_convertSparseTileRegions :: proc(self: ^Device, tileRegions: ^Region, pixelRegions: ^Region, tileSize: Size, numRegions: ^NS.Object) { + msgSend(nil, self, "convertSparseTileRegions:toPixelRegions:withTileSize:numRegions:", tileRegions, pixelRegions, tileSize, numRegions) +} +@(objc_type=Device, objc_name="counterSets") +Device_counterSets :: proc(self: ^Device) -> ^NS.Array { + return msgSend(^NS.Array, self, "counterSets") +} +@(objc_type=Device, objc_name="currentAllocatedSize") +Device_currentAllocatedSize :: proc(self: ^Device) -> NS.Integer { + return msgSend(NS.Integer, self, "currentAllocatedSize") +} +@(objc_type=Device, objc_name="getDefaultSamplePositions") +Device_getDefaultSamplePositions :: proc(self: ^Device, positions: ^SamplePosition, count: ^NS.Object) { + msgSend(nil, self, "getDefaultSamplePositions:count:", positions, count) +} +@(objc_type=Device, objc_name="hasUnifiedMemory") +Device_hasUnifiedMemory :: proc(self: ^Device) -> BOOL { + return msgSend(BOOL, self, "hasUnifiedMemory") +} +@(objc_type=Device, objc_name="heapBufferSizeAndAlignWithLength") +Device_heapBufferSizeAndAlignWithLength :: proc(self: ^Device, length: ^NS.Object, options: ResourceOptions) -> SizeAndAlign { + return msgSend(SizeAndAlign, self, "heapBufferSizeAndAlignWithLength:options:", length, options) +} +@(objc_type=Device, objc_name="heapTextureSizeAndAlignWithDescriptor") +Device_heapTextureSizeAndAlignWithDescriptor :: proc(self: ^Device, desc: ^TextureDescriptor) -> SizeAndAlign { + return msgSend(SizeAndAlign, self, "heapTextureSizeAndAlignWithDescriptor:", desc) +} +@(objc_type=Device, objc_name="isDepth24Stencil8PixelFormatSupported") +Device_isDepth24Stencil8PixelFormatSupported :: proc(self: ^Device) -> BOOL { + return msgSend(BOOL, self, "isDepth24Stencil8PixelFormatSupported") +} +@(objc_type=Device, objc_name="isHeadless") +Device_isHeadless :: proc(self: ^Device) -> BOOL { + return msgSend(BOOL, self, "isHeadless") +} +@(objc_type=Device, objc_name="isLowPower") +Device_isLowPower :: proc(self: ^Device) -> BOOL { + return msgSend(BOOL, self, "isLowPower") +} +@(objc_type=Device, objc_name="isRemovable") +Device_isRemovable :: proc(self: ^Device) -> BOOL { + return msgSend(BOOL, self, "isRemovable") +} +@(objc_type=Device, objc_name="location") +Device_location :: proc(self: ^Device) -> DeviceLocation { + return msgSend(DeviceLocation, self, "location") +} +@(objc_type=Device, objc_name="locationNumber") +Device_locationNumber :: proc(self: ^Device) -> NS.Integer { + return msgSend(NS.Integer, self, "locationNumber") +} +@(objc_type=Device, objc_name="maxArgumentBufferSamplerCount") +Device_maxArgumentBufferSamplerCount :: proc(self: ^Device) -> NS.Integer { + return msgSend(NS.Integer, self, "maxArgumentBufferSamplerCount") +} +@(objc_type=Device, objc_name="maxBufferLength") +Device_maxBufferLength :: proc(self: ^Device) -> NS.Integer { + return msgSend(NS.Integer, self, "maxBufferLength") +} +@(objc_type=Device, objc_name="maxThreadgroupMemoryLength") +Device_maxThreadgroupMemoryLength :: proc(self: ^Device) -> NS.Integer { + return msgSend(NS.Integer, self, "maxThreadgroupMemoryLength") +} +@(objc_type=Device, objc_name="maxThreadsPerThreadgroup") +Device_maxThreadsPerThreadgroup :: proc(self: ^Device) -> Size { + return msgSend(Size, self, "maxThreadsPerThreadgroup") +} +@(objc_type=Device, objc_name="maxTransferRate") +Device_maxTransferRate :: proc(self: ^Device) -> u64 { + return msgSend(u64, self, "maxTransferRate") +} +@(objc_type=Device, objc_name="minimumLinearTextureAlignmentForPixelFormat") +Device_minimumLinearTextureAlignmentForPixelFormat :: proc(self: ^Device, format: PixelFormat) -> ^Device { + return msgSend(^Device, self, "minimumLinearTextureAlignmentForPixelFormat:", format) +} +@(objc_type=Device, objc_name="minimumTextureBufferAlignmentForPixelFormat") +Device_minimumTextureBufferAlignmentForPixelFormat :: proc(self: ^Device, format: PixelFormat) -> ^Device { + return msgSend(^Device, self, "minimumTextureBufferAlignmentForPixelFormat:", format) +} +@(objc_type=Device, objc_name="name") +Device_name :: proc(self: ^Device) -> ^NS.String { + return msgSend(^NS.String, self, "name") +} +@(objc_type=Device, objc_name="newAccelerationStructureWithDescriptor") +Device_newAccelerationStructureWithDescriptor :: proc(self: ^Device, descriptor: ^AccelerationStructureDescriptor) -> ^Device { + return msgSend(^Device, self, "newAccelerationStructureWithDescriptor:", descriptor) +} +@(objc_type=Device, objc_name="newAccelerationStructureWithSize") +Device_newAccelerationStructureWithSize :: proc(self: ^Device, size: ^NS.Object) -> ^Device { + return msgSend(^Device, self, "newAccelerationStructureWithSize:", size) +} +@(objc_type=Device, objc_name="newArgumentEncoderWithArguments") +Device_newArgumentEncoderWithArguments :: proc(self: ^Device, arguments: ^NS.Array) -> ^Device { + return msgSend(^Device, self, "newArgumentEncoderWithArguments:", arguments) +} +@(objc_type=Device, objc_name="newBinaryArchiveWithDescriptor") +Device_newBinaryArchiveWithDescriptor :: proc(self: ^Device, descriptor: ^BinaryArchiveDescriptor, error: ^^NS.Error ) -> ^Device { + return msgSend(^Device, self, "newBinaryArchiveWithDescriptor:error:", descriptor, error) +} +@(objc_type=Device, objc_name="newBufferWithBytes") +Device_newBufferWithBytes :: proc(self: ^Device, pointer: rawptr, length: ^NS.Object, options: ResourceOptions) -> ^Device { + return msgSend(^Device, self, "newBufferWithBytes:length:options:", pointer, length, options) +} +@(objc_type=Device, objc_name="newBufferWithBytesNoCopy") +Device_newBufferWithBytesNoCopy :: proc(self: ^Device, pointer: rawptr, length: ^NS.Object, options: ResourceOptions, deallocator: rawptr) -> ^Device { + return msgSend(^Device, self, "newBufferWithBytesNoCopy:length:options:deallocator:", pointer, length, options, deallocator) +} +@(objc_type=Device, objc_name="newBufferWithLength") +Device_newBufferWithLength :: proc(self: ^Device, length: ^NS.Object, options: ResourceOptions) -> ^Device { + return msgSend(^Device, self, "newBufferWithLength:options:", length, options) +} +@(objc_type=Device, objc_name="newCommandQueue") +Device_newCommandQueue :: proc(self: ^Device) -> ^Device { + return msgSend(^Device, self, "newCommandQueue") +} +@(objc_type=Device, objc_name="newCommandQueueWithMaxCommandBufferCount") +Device_newCommandQueueWithMaxCommandBufferCount :: proc(self: ^Device, maxCommandBufferCount: ^NS.Object) -> ^Device { + return msgSend(^Device, self, "newCommandQueueWithMaxCommandBufferCount:", maxCommandBufferCount) +} +@(objc_type=Device, objc_name="newComputePipelineStateWithDescriptor_options_completionHandler_") +Device_newComputePipelineStateWithDescriptor_options_completionHandler_ :: proc(self: ^Device, descriptor: ^ComputePipelineDescriptor, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) { + msgSend(nil, self, "newComputePipelineStateWithDescriptor:options:completionHandler:", descriptor, options, completionHandler) +} +@(objc_type=Device, objc_name="newComputePipelineStateWithDescriptor_options_reflection_error_") +Device_newComputePipelineStateWithDescriptor_options_reflection_error_ :: proc(self: ^Device, descriptor: ^ComputePipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection, error: ^^NS.Error ) -> ^Device { + return msgSend(^Device, self, "newComputePipelineStateWithDescriptor:options:reflection:error:", descriptor, options, reflection, error) +} +@(objc_type=Device, objc_name="newComputePipelineStateWithFunction_completionHandler_") +Device_newComputePipelineStateWithFunction_completionHandler_ :: proc(self: ^Device, computeFunction: ^NS.Object, completionHandler: NewComputePipelineStateCompletionHandler) { + msgSend(nil, self, "newComputePipelineStateWithFunction:completionHandler:", computeFunction, completionHandler) +} +@(objc_type=Device, objc_name="newComputePipelineStateWithFunction_error_") +Device_newComputePipelineStateWithFunction_error_ :: proc(self: ^Device, computeFunction: ^NS.Object, error: ^^NS.Error ) -> ^Device { + return msgSend(^Device, self, "newComputePipelineStateWithFunction:error:", computeFunction, error) +} +@(objc_type=Device, objc_name="newComputePipelineStateWithFunction_options_completionHandler_") +Device_newComputePipelineStateWithFunction_options_completionHandler_ :: proc(self: ^Device, computeFunction: ^NS.Object, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) { + msgSend(nil, self, "newComputePipelineStateWithFunction:options:completionHandler:", computeFunction, options, completionHandler) +} +@(objc_type=Device, objc_name="newComputePipelineStateWithFunction_options_reflection_error_") +Device_newComputePipelineStateWithFunction_options_reflection_error_ :: proc(self: ^Device, computeFunction: ^NS.Object, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection, error: ^^NS.Error ) -> ^Device { + return msgSend(^Device, self, "newComputePipelineStateWithFunction:options:reflection:error:", computeFunction, options, reflection, error) +} +@(objc_type=Device, objc_name="newCounterSampleBufferWithDescriptor") +Device_newCounterSampleBufferWithDescriptor :: proc(self: ^Device, descriptor: ^CounterSampleBufferDescriptor, error: ^^NS.Error ) -> ^Device { + return msgSend(^Device, self, "newCounterSampleBufferWithDescriptor:error:", descriptor, error) +} +@(objc_type=Device, objc_name="newDefaultLibrary") +Device_newDefaultLibrary :: proc(self: ^Device) -> ^Device { + return msgSend(^Device, self, "newDefaultLibrary") +} +@(objc_type=Device, objc_name="newDefaultLibraryWithBundle") +Device_newDefaultLibraryWithBundle :: proc(self: ^Device, bundle: ^NS.Bundle, error: ^^NS.Error ) -> ^Device { + return msgSend(^Device, self, "newDefaultLibraryWithBundle:error:", bundle, error) +} +@(objc_type=Device, objc_name="newDepthStencilStateWithDescriptor") +Device_newDepthStencilStateWithDescriptor :: proc(self: ^Device, descriptor: ^DepthStencilDescriptor) -> ^Device { + return msgSend(^Device, self, "newDepthStencilStateWithDescriptor:", descriptor) +} +@(objc_type=Device, objc_name="newDynamicLibrary") +Device_newDynamicLibrary :: proc(self: ^Device, library: ^NS.Object, error: ^^NS.Error ) -> ^Device { + return msgSend(^Device, self, "newDynamicLibrary:error:", library, error) +} +@(objc_type=Device, objc_name="newDynamicLibraryWithURL") +Device_newDynamicLibraryWithURL :: proc(self: ^Device, url: ^NS.URL, error: ^^NS.Error ) -> ^Device { + return msgSend(^Device, self, "newDynamicLibraryWithURL:error:", url, error) +} +@(objc_type=Device, objc_name="newEvent") +Device_newEvent :: proc(self: ^Device) -> ^Device { + return msgSend(^Device, self, "newEvent") +} +@(objc_type=Device, objc_name="newFence") +Device_newFence :: proc(self: ^Device) -> ^Device { + return msgSend(^Device, self, "newFence") +} +@(objc_type=Device, objc_name="newHeapWithDescriptor") +Device_newHeapWithDescriptor :: proc(self: ^Device, descriptor: ^HeapDescriptor) -> ^Device { + return msgSend(^Device, self, "newHeapWithDescriptor:", descriptor) +} +@(objc_type=Device, objc_name="newIndirectCommandBufferWithDescriptor") +Device_newIndirectCommandBufferWithDescriptor :: proc(self: ^Device, descriptor: ^IndirectCommandBufferDescriptor, maxCount: ^NS.Object, options: ResourceOptions) -> ^Device { + return msgSend(^Device, self, "newIndirectCommandBufferWithDescriptor:maxCommandCount:options:", descriptor, maxCount, options) +} +@(objc_type=Device, objc_name="newLibraryWithData") +Device_newLibraryWithData :: proc(self: ^Device, data: ^NS.Object, error: ^^NS.Error ) -> ^Device { + return msgSend(^Device, self, "newLibraryWithData:error:", data, error) +} +@(objc_type=Device, objc_name="newLibraryWithFile") +Device_newLibraryWithFile :: proc(self: ^Device, filepath: ^NS.String, error: ^^NS.Error ) -> ^Device { + return msgSend(^Device, self, "newLibraryWithFile:error:", filepath, error) +} +@(objc_type=Device, objc_name="newLibraryWithSource_options_completionHandler_") +Device_newLibraryWithSource_options_completionHandler_ :: proc(self: ^Device, source: ^NS.String, options: ^CompileOptions, completionHandler: NewLibraryCompletionHandler) { + msgSend(nil, self, "newLibraryWithSource:options:completionHandler:", source, options, completionHandler) +} +@(objc_type=Device, objc_name="newLibraryWithSource_options_error_") +Device_newLibraryWithSource_options_error_ :: proc(self: ^Device, source: ^NS.String, options: ^CompileOptions, error: ^^NS.Error ) -> ^Device { + return msgSend(^Device, self, "newLibraryWithSource:options:error:", source, options, error) +} +@(objc_type=Device, objc_name="newLibraryWithURL") +Device_newLibraryWithURL :: proc(self: ^Device, url: ^NS.URL, error: ^^NS.Error ) -> ^Device { + return msgSend(^Device, self, "newLibraryWithURL:error:", url, error) +} +@(objc_type=Device, objc_name="newRasterizationRateMapWithDescriptor") +Device_newRasterizationRateMapWithDescriptor :: proc(self: ^Device, descriptor: ^RasterizationRateMapDescriptor) -> ^Device { + return msgSend(^Device, self, "newRasterizationRateMapWithDescriptor:", descriptor) +} +@(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor_completionHandler_") +Device_newRenderPipelineStateWithDescriptor_completionHandler_ :: proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, completionHandler: NewRenderPipelineStateCompletionHandler) { + msgSend(nil, self, "newRenderPipelineStateWithDescriptor:completionHandler:", descriptor, completionHandler) +} +@(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor_error_") +Device_newRenderPipelineStateWithDescriptor_error_ :: proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, error: ^^NS.Error ) -> ^Device { + return msgSend(^Device, self, "newRenderPipelineStateWithDescriptor:error:", descriptor, error) +} +@(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor_options_completionHandler_") +Device_newRenderPipelineStateWithDescriptor_options_completionHandler_ :: proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, completionHandler: NewRenderPipelineStateWithReflectionCompletionHandler) { + msgSend(nil, self, "newRenderPipelineStateWithDescriptor:options:completionHandler:", descriptor, options, completionHandler) +} +@(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor_options_reflection_error_") +Device_newRenderPipelineStateWithDescriptor_options_reflection_error_ :: proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection, error: ^^NS.Error ) -> ^Device { + return msgSend(^Device, self, "newRenderPipelineStateWithDescriptor:options:reflection:error:", descriptor, options, reflection, error) +} +@(objc_type=Device, objc_name="newRenderPipelineStateWithTileDescriptor_options_completionHandler_") +Device_newRenderPipelineStateWithTileDescriptor_options_completionHandler_ :: proc(self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, completionHandler: NewRenderPipelineStateWithReflectionCompletionHandler) { + msgSend(nil, self, "newRenderPipelineStateWithTileDescriptor:options:completionHandler:", descriptor, options, completionHandler) +} +@(objc_type=Device, objc_name="newRenderPipelineStateWithTileDescriptor_options_reflection_error_") +Device_newRenderPipelineStateWithTileDescriptor_options_reflection_error_ :: proc(self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection, error: ^^NS.Error ) -> ^Device { + return msgSend(^Device, self, "newRenderPipelineStateWithTileDescriptor:options:reflection:error:", descriptor, options, reflection, error) +} +@(objc_type=Device, objc_name="newSamplerStateWithDescriptor") +Device_newSamplerStateWithDescriptor :: proc(self: ^Device, descriptor: ^SamplerDescriptor) -> ^Device { + return msgSend(^Device, self, "newSamplerStateWithDescriptor:", descriptor) +} +@(objc_type=Device, objc_name="newSharedEvent") +Device_newSharedEvent :: proc(self: ^Device) -> ^Device { + return msgSend(^Device, self, "newSharedEvent") +} +@(objc_type=Device, objc_name="newSharedEventWithHandle") +Device_newSharedEventWithHandle :: proc(self: ^Device, sharedEventHandle: ^SharedEventHandle) -> ^Device { + return msgSend(^Device, self, "newSharedEventWithHandle:", sharedEventHandle) +} +@(objc_type=Device, objc_name="newSharedTextureWithDescriptor") +Device_newSharedTextureWithDescriptor :: proc(self: ^Device, descriptor: ^TextureDescriptor) -> ^Device { + return msgSend(^Device, self, "newSharedTextureWithDescriptor:", descriptor) +} +@(objc_type=Device, objc_name="newSharedTextureWithHandle") +Device_newSharedTextureWithHandle :: proc(self: ^Device, sharedHandle: ^SharedTextureHandle) -> ^Device { + return msgSend(^Device, self, "newSharedTextureWithHandle:", sharedHandle) +} +@(objc_type=Device, objc_name="newTextureWithDescriptor") +Device_newTextureWithDescriptor :: proc(self: ^Device, desc: ^TextureDescriptor) -> ^Device { + return msgSend(^Device, self, "newTextureWithDescriptor:", desc) +} +@(objc_type=Device, objc_name="newTextureWithDescriptor_iosurface_plane_") +Device_newTextureWithDescriptor_iosurface_plane_ :: proc(self: ^Device, descriptor: ^TextureDescriptor, iosurface: IOSurfaceRef, plane: ^NS.Object) -> ^Device { + return msgSend(^Device, self, "newTextureWithDescriptor:iosurface:plane:", descriptor, iosurface, plane) +} +@(objc_type=Device, objc_name="peerCount") +Device_peerCount :: proc(self: ^Device) -> u32 { + return msgSend(u32, self, "peerCount") +} +@(objc_type=Device, objc_name="peerGroupID") +Device_peerGroupID :: proc(self: ^Device) -> u64 { + return msgSend(u64, self, "peerGroupID") +} +@(objc_type=Device, objc_name="peerIndex") +Device_peerIndex :: proc(self: ^Device) -> u32 { + return msgSend(u32, self, "peerIndex") +} +@(objc_type=Device, objc_name="readWriteTextureSupport") +Device_readWriteTextureSupport :: proc(self: ^Device) -> ReadWriteTextureTier { + return msgSend(ReadWriteTextureTier, self, "readWriteTextureSupport") +} +@(objc_type=Device, objc_name="recommendedMaxWorkingSetSize") +Device_recommendedMaxWorkingSetSize :: proc(self: ^Device) -> u64 { + return msgSend(u64, self, "recommendedMaxWorkingSetSize") +} +@(objc_type=Device, objc_name="registryID") +Device_registryID :: proc(self: ^Device) -> u64 { + return msgSend(u64, self, "registryID") +} +@(objc_type=Device, objc_name="sampleTimestamps") +Device_sampleTimestamps :: proc(self: ^Device, cpuTimestamp: ^Timestamp, gpuTimestamp: ^Timestamp) { + msgSend(nil, self, "sampleTimestamps:gpuTimestamp:", cpuTimestamp, gpuTimestamp) +} +@(objc_type=Device, objc_name="sparseTileSizeInBytes") +Device_sparseTileSizeInBytes :: proc(self: ^Device) -> NS.Integer { + return msgSend(NS.Integer, self, "sparseTileSizeInBytes") +} +@(objc_type=Device, objc_name="sparseTileSizeWithTextureType") +Device_sparseTileSizeWithTextureType :: proc(self: ^Device, textureType: TextureType, pixelFormat: PixelFormat, sampleCount: ^NS.Object) -> Size { + return msgSend(Size, self, "sparseTileSizeWithTextureType:pixelFormat:sampleCount:", textureType, pixelFormat, sampleCount) +} +@(objc_type=Device, objc_name="supports32BitFloatFiltering") +Device_supports32BitFloatFiltering :: proc(self: ^Device) -> BOOL { + return msgSend(BOOL, self, "supports32BitFloatFiltering") +} +@(objc_type=Device, objc_name="supports32BitMSAA") +Device_supports32BitMSAA :: proc(self: ^Device) -> BOOL { + return msgSend(BOOL, self, "supports32BitMSAA") +} +@(objc_type=Device, objc_name="supportsBCTextureCompression") +Device_supportsBCTextureCompression :: proc(self: ^Device) -> BOOL { + return msgSend(BOOL, self, "supportsBCTextureCompression") +} +@(objc_type=Device, objc_name="supportsCounterSampling") +Device_supportsCounterSampling :: proc(self: ^Device, samplingPoint: CounterSamplingPoint) -> BOOL { + return msgSend(BOOL, self, "supportsCounterSampling:", samplingPoint) +} +@(objc_type=Device, objc_name="supportsDynamicLibraries") +Device_supportsDynamicLibraries :: proc(self: ^Device) -> BOOL { + return msgSend(BOOL, self, "supportsDynamicLibraries") +} +@(objc_type=Device, objc_name="supportsFamily") +Device_supportsFamily :: proc(self: ^Device, gpuFamily: GPUFamily) -> BOOL { + return msgSend(BOOL, self, "supportsFamily:", gpuFamily) +} +@(objc_type=Device, objc_name="supportsFeatureSet") +Device_supportsFeatureSet :: proc(self: ^Device, featureSet: FeatureSet) -> BOOL { + return msgSend(BOOL, self, "supportsFeatureSet:", featureSet) +} +@(objc_type=Device, objc_name="supportsFunctionPointers") +Device_supportsFunctionPointers :: proc(self: ^Device) -> BOOL { + return msgSend(BOOL, self, "supportsFunctionPointers") +} +@(objc_type=Device, objc_name="supportsPullModelInterpolation") +Device_supportsPullModelInterpolation :: proc(self: ^Device) -> BOOL { + return msgSend(BOOL, self, "supportsPullModelInterpolation") +} +@(objc_type=Device, objc_name="supportsQueryTextureLOD") +Device_supportsQueryTextureLOD :: proc(self: ^Device) -> BOOL { + return msgSend(BOOL, self, "supportsQueryTextureLOD") +} +@(objc_type=Device, objc_name="supportsRasterizationRateMapWithLayerCount") +Device_supportsRasterizationRateMapWithLayerCount :: proc(self: ^Device, layerCount: ^NS.Object) -> BOOL { + return msgSend(BOOL, self, "supportsRasterizationRateMapWithLayerCount:", layerCount) +} +@(objc_type=Device, objc_name="supportsRaytracing") +Device_supportsRaytracing :: proc(self: ^Device) -> BOOL { + return msgSend(BOOL, self, "supportsRaytracing") +} +@(objc_type=Device, objc_name="supportsShaderBarycentricCoordinates") +Device_supportsShaderBarycentricCoordinates :: proc(self: ^Device) -> BOOL { + return msgSend(BOOL, self, "supportsShaderBarycentricCoordinates") +} +@(objc_type=Device, objc_name="supportsTextureSampleCount") +Device_supportsTextureSampleCount :: proc(self: ^Device, sampleCount: ^NS.Object) -> BOOL { + return msgSend(BOOL, self, "supportsTextureSampleCount:", sampleCount) +} +@(objc_type=Device, objc_name="supportsVertexAmplificationCount") +Device_supportsVertexAmplificationCount :: proc(self: ^Device, count: ^NS.Object) -> BOOL { + return msgSend(BOOL, self, "supportsVertexAmplificationCount:", count) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + Drawable +Class Methods: +Methods: + addPresentedHandler + drawableID + present + presentAfterMinimumDuration + presentAtTime + presentedTime +*/ +@(objc_class="MTLDrawable") +Drawable :: struct { using _: NS.Object } + +@(objc_type=Drawable, objc_name="addPresentedHandler") +Drawable_addPresentedHandler :: proc(self: ^Drawable, block: DrawablePresentedHandler) { + msgSend(nil, self, "addPresentedHandler:", block) +} +@(objc_type=Drawable, objc_name="drawableID") +Drawable_drawableID :: proc(self: ^Drawable) -> NS.Integer { + return msgSend(NS.Integer, self, "drawableID") +} +@(objc_type=Drawable, objc_name="present") +Drawable_present :: proc(self: ^Drawable) { + msgSend(nil, self, "present") +} +@(objc_type=Drawable, objc_name="presentAfterMinimumDuration") +Drawable_presentAfterMinimumDuration :: proc(self: ^Drawable, duration: CFTimeInterval) { + msgSend(nil, self, "presentAfterMinimumDuration:", duration) +} +@(objc_type=Drawable, objc_name="presentAtTime") +Drawable_presentAtTime :: proc(self: ^Drawable, presentationTime: CFTimeInterval) { + msgSend(nil, self, "presentAtTime:", presentationTime) +} +@(objc_type=Drawable, objc_name="presentedTime") +Drawable_presentedTime :: proc(self: ^Drawable) -> CFTimeInterval { + return msgSend(CFTimeInterval, self, "presentedTime") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + DynamicLibrary +Class Methods: +Methods: + device + installName + label + serializeToURL + setLabel +*/ +@(objc_class="MTLDynamicLibrary") +DynamicLibrary :: struct { using _: NS.Object } + +@(objc_type=DynamicLibrary, objc_name="device") +DynamicLibrary_device :: proc(self: ^DynamicLibrary) -> ^DynamicLibrary { + return msgSend(^DynamicLibrary, self, "device") +} +@(objc_type=DynamicLibrary, objc_name="installName") +DynamicLibrary_installName :: proc(self: ^DynamicLibrary) -> ^NS.String { + return msgSend(^NS.String, self, "installName") +} +@(objc_type=DynamicLibrary, objc_name="label") +DynamicLibrary_label :: proc(self: ^DynamicLibrary) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=DynamicLibrary, objc_name="serializeToURL") +DynamicLibrary_serializeToURL :: proc(self: ^DynamicLibrary, url: ^NS.URL, error: ^^NS.Error ) -> BOOL { + return msgSend(BOOL, self, "serializeToURL:error:", url, error) +} +@(objc_type=DynamicLibrary, objc_name="setLabel") +DynamicLibrary_setLabel :: proc(self: ^DynamicLibrary, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + Event +Class Methods: +Methods: + device + label + setLabel +*/ +@(objc_class="MTLEvent") +Event :: struct { using _: NS.Object } + +@(objc_type=Event, objc_name="device") +Event_device :: proc(self: ^Event) -> ^Event { + return msgSend(^Event, self, "device") +} +@(objc_type=Event, objc_name="label") +Event_label :: proc(self: ^Event) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=Event, objc_name="setLabel") +Event_setLabel :: proc(self: ^Event, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + Fence +Class Methods: +Methods: + device + label + setLabel +*/ +@(objc_class="MTLFence") +Fence :: struct { using _: NS.Object } + +@(objc_type=Fence, objc_name="device") +Fence_device :: proc(self: ^Fence) -> ^Fence { + return msgSend(^Fence, self, "device") +} +@(objc_type=Fence, objc_name="label") +Fence_label :: proc(self: ^Fence) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=Fence, objc_name="setLabel") +Fence_setLabel :: proc(self: ^Fence, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + Function +Class Methods: +Methods: + device + functionConstantsDictionary + functionType + label + name + newArgumentEncoderWithBufferIndex + newArgumentEncoderWithBufferIndex + options + patchControlPointCount + patchType + setLabel + stageInputAttributes + vertexAttributes +*/ +@(objc_class="MTLFunction") +Function :: struct { using _: NS.Object } + +@(objc_type=Function, objc_name="device") +Function_device :: proc(self: ^Function) -> ^Function { + return msgSend(^Function, self, "device") +} +@(objc_type=Function, objc_name="functionConstantsDictionary") +Function_functionConstantsDictionary :: proc(self: ^Function) -> ^NS.Dictionary { + return msgSend(^NS.Dictionary, self, "functionConstantsDictionary") +} +@(objc_type=Function, objc_name="functionType") +Function_functionType :: proc(self: ^Function) -> FunctionType { + return msgSend(FunctionType, self, "functionType") +} +@(objc_type=Function, objc_name="label") +Function_label :: proc(self: ^Function) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=Function, objc_name="name") +Function_name :: proc(self: ^Function) -> ^NS.String { + return msgSend(^NS.String, self, "name") +} +@(objc_type=Function, objc_name="newArgumentEncoderWithBufferIndex") +Function_newArgumentEncoderWithBufferIndex :: proc(self: ^Function, bufferIndex: ^NS.Object) -> ^Function { + return msgSend(^Function, self, "newArgumentEncoderWithBufferIndex:", bufferIndex) +} +@(objc_type=Function, objc_name="newArgumentEncoderWithBufferIndex_reflection_") +Function_newArgumentEncoderWithBufferIndex_reflection_ :: proc(self: ^Function, bufferIndex: ^NS.Object, reflection: ^AutoreleasedArgument) -> ^Function { + return msgSend(^Function, self, "newArgumentEncoderWithBufferIndex:reflection:", bufferIndex, reflection) +} +@(objc_type=Function, objc_name="options") +Function_options :: proc(self: ^Function) -> FunctionOptions { + return msgSend(FunctionOptions, self, "options") +} +@(objc_type=Function, objc_name="patchControlPointCount") +Function_patchControlPointCount :: proc(self: ^Function) -> NS.Integer { + return msgSend(NS.Integer, self, "patchControlPointCount") +} +@(objc_type=Function, objc_name="patchType") +Function_patchType :: proc(self: ^Function) -> PatchType { + return msgSend(PatchType, self, "patchType") +} +@(objc_type=Function, objc_name="setLabel") +Function_setLabel :: proc(self: ^Function, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} +@(objc_type=Function, objc_name="stageInputAttributes") +Function_stageInputAttributes :: proc(self: ^Function) -> ^NS.Array { + return msgSend(^NS.Array, self, "stageInputAttributes") +} +@(objc_type=Function, objc_name="vertexAttributes") +Function_vertexAttributes :: proc(self: ^Function) -> ^NS.Array { + return msgSend(^NS.Array, self, "vertexAttributes") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + FunctionHandle +Class Methods: +Methods: + device + functionType + name +*/ +@(objc_class="MTLFunctionHandle") +FunctionHandle :: struct { using _: NS.Object } + +@(objc_type=FunctionHandle, objc_name="device") +FunctionHandle_device :: proc(self: ^FunctionHandle) -> ^FunctionHandle { + return msgSend(^FunctionHandle, self, "device") +} +@(objc_type=FunctionHandle, objc_name="functionType") +FunctionHandle_functionType :: proc(self: ^FunctionHandle) -> FunctionType { + return msgSend(FunctionType, self, "functionType") +} +@(objc_type=FunctionHandle, objc_name="name") +FunctionHandle_name :: proc(self: ^FunctionHandle) -> ^NS.String { + return msgSend(^NS.String, self, "name") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + FunctionLog +Class Methods: +Methods: + debugLocation + encoderLabel + function + type +*/ +@(objc_class="MTLFunctionLog") +FunctionLog :: struct { using _: NS.Object } + +@(objc_type=FunctionLog, objc_name="debugLocation") +FunctionLog_debugLocation :: proc(self: ^FunctionLog) -> ^FunctionLog { + return msgSend(^FunctionLog, self, "debugLocation") +} +@(objc_type=FunctionLog, objc_name="encoderLabel") +FunctionLog_encoderLabel :: proc(self: ^FunctionLog) -> ^NS.String { + return msgSend(^NS.String, self, "encoderLabel") +} +@(objc_type=FunctionLog, objc_name="function") +FunctionLog_function :: proc(self: ^FunctionLog) -> ^FunctionLog { + return msgSend(^FunctionLog, self, "function") +} +@(objc_type=FunctionLog, objc_name="type") +FunctionLog_type :: proc(self: ^FunctionLog) -> FunctionLogType { + return msgSend(FunctionLogType, self, "type") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + FunctionLogDebugLocation +Class Methods: +Methods: + URL + column + functionName + line +*/ +@(objc_class="MTLFunctionLogDebugLocation") +FunctionLogDebugLocation :: struct { using _: NS.Object } + +@(objc_type=FunctionLogDebugLocation, objc_name="URL") +FunctionLogDebugLocation_URL :: proc(self: ^FunctionLogDebugLocation) -> ^NS.URL { + return msgSend(^NS.URL, self, "URL") +} +@(objc_type=FunctionLogDebugLocation, objc_name="column") +FunctionLogDebugLocation_column :: proc(self: ^FunctionLogDebugLocation) -> NS.Integer { + return msgSend(NS.Integer, self, "column") +} +@(objc_type=FunctionLogDebugLocation, objc_name="functionName") +FunctionLogDebugLocation_functionName :: proc(self: ^FunctionLogDebugLocation) -> ^NS.String { + return msgSend(^NS.String, self, "functionName") +} +@(objc_type=FunctionLogDebugLocation, objc_name="line") +FunctionLogDebugLocation_line :: proc(self: ^FunctionLogDebugLocation) -> NS.Integer { + return msgSend(NS.Integer, self, "line") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + Heap +Class Methods: +Methods: + cpuCacheMode + currentAllocatedSize + device + hazardTrackingMode + label + maxAvailableSizeWithAlignment + newBufferWithLength + newBufferWithLength + newTextureWithDescriptor + newTextureWithDescriptor + resourceOptions + setLabel + setPurgeableState + size + storageMode + type + usedSize +*/ +@(objc_class="MTLHeap") +Heap :: struct { using _: NS.Object } + +@(objc_type=Heap, objc_name="cpuCacheMode") +Heap_cpuCacheMode :: proc(self: ^Heap) -> CPUCacheMode { + return msgSend(CPUCacheMode, self, "cpuCacheMode") +} +@(objc_type=Heap, objc_name="currentAllocatedSize") +Heap_currentAllocatedSize :: proc(self: ^Heap) -> NS.Integer { + return msgSend(NS.Integer, self, "currentAllocatedSize") +} +@(objc_type=Heap, objc_name="device") +Heap_device :: proc(self: ^Heap) -> ^Heap { + return msgSend(^Heap, self, "device") +} +@(objc_type=Heap, objc_name="hazardTrackingMode") +Heap_hazardTrackingMode :: proc(self: ^Heap) -> HazardTrackingMode { + return msgSend(HazardTrackingMode, self, "hazardTrackingMode") +} +@(objc_type=Heap, objc_name="label") +Heap_label :: proc(self: ^Heap) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=Heap, objc_name="maxAvailableSizeWithAlignment") +Heap_maxAvailableSizeWithAlignment :: proc(self: ^Heap, alignment: ^NS.Object) -> ^Heap { + return msgSend(^Heap, self, "maxAvailableSizeWithAlignment:", alignment) +} +@(objc_type=Heap, objc_name="newBufferWithLength") +Heap_newBufferWithLength :: proc(self: ^Heap, length: ^NS.Object, options: ResourceOptions) -> ^Heap { + return msgSend(^Heap, self, "newBufferWithLength:options:", length, options) +} +@(objc_type=Heap, objc_name="newBufferWithLength_options_offset_") +Heap_newBufferWithLength_options_offset_ :: proc(self: ^Heap, length: ^NS.Object, options: ResourceOptions, offset: ^NS.Object) -> ^Heap { + return msgSend(^Heap, self, "newBufferWithLength:options:offset:", length, options, offset) +} +@(objc_type=Heap, objc_name="newTextureWithDescriptor") +Heap_newTextureWithDescriptor :: proc(self: ^Heap, desc: ^TextureDescriptor) -> ^Heap { + return msgSend(^Heap, self, "newTextureWithDescriptor:", desc) +} +@(objc_type=Heap, objc_name="newTextureWithDescriptor_offset_") +Heap_newTextureWithDescriptor_offset_ :: proc(self: ^Heap, descriptor: ^TextureDescriptor, offset: ^NS.Object) -> ^Heap { + return msgSend(^Heap, self, "newTextureWithDescriptor:offset:", descriptor, offset) +} +@(objc_type=Heap, objc_name="resourceOptions") +Heap_resourceOptions :: proc(self: ^Heap) -> ResourceOptions { + return msgSend(ResourceOptions, self, "resourceOptions") +} +@(objc_type=Heap, objc_name="setLabel") +Heap_setLabel :: proc(self: ^Heap, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} +@(objc_type=Heap, objc_name="setPurgeableState") +Heap_setPurgeableState :: proc(self: ^Heap, state: PurgeableState) -> PurgeableState { + return msgSend(PurgeableState, self, "setPurgeableState:", state) +} +@(objc_type=Heap, objc_name="size") +Heap_size :: proc(self: ^Heap) -> NS.Integer { + return msgSend(NS.Integer, self, "size") +} +@(objc_type=Heap, objc_name="storageMode") +Heap_storageMode :: proc(self: ^Heap) -> StorageMode { + return msgSend(StorageMode, self, "storageMode") +} +@(objc_type=Heap, objc_name="type") +Heap_type :: proc(self: ^Heap) -> FunctionLogType { + return msgSend(FunctionLogType, self, "type") +} +@(objc_type=Heap, objc_name="usedSize") +Heap_usedSize :: proc(self: ^Heap) -> NS.Integer { + return msgSend(NS.Integer, self, "usedSize") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + IndirectCommandBuffer +Class Methods: +Methods: + indirectComputeCommandAtIndex + indirectRenderCommandAtIndex + resetWithRange + size +*/ +@(objc_class="MTLIndirectCommandBuffer") +IndirectCommandBuffer :: struct { using _: NS.Object } + +@(objc_type=IndirectCommandBuffer, objc_name="indirectComputeCommandAtIndex") +IndirectCommandBuffer_indirectComputeCommandAtIndex :: proc(self: ^IndirectCommandBuffer, commandIndex: ^NS.Object) -> ^IndirectCommandBuffer { + return msgSend(^IndirectCommandBuffer, self, "indirectComputeCommandAtIndex:", commandIndex) +} +@(objc_type=IndirectCommandBuffer, objc_name="indirectRenderCommandAtIndex") +IndirectCommandBuffer_indirectRenderCommandAtIndex :: proc(self: ^IndirectCommandBuffer, commandIndex: ^NS.Object) -> ^IndirectCommandBuffer { + return msgSend(^IndirectCommandBuffer, self, "indirectRenderCommandAtIndex:", commandIndex) +} +@(objc_type=IndirectCommandBuffer, objc_name="resetWithRange") +IndirectCommandBuffer_resetWithRange :: proc(self: ^IndirectCommandBuffer, range: NS.Range) { + msgSend(nil, self, "resetWithRange:", range) +} +@(objc_type=IndirectCommandBuffer, objc_name="size") +IndirectCommandBuffer_size :: proc(self: ^IndirectCommandBuffer) -> NS.Integer { + return msgSend(NS.Integer, self, "size") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + IndirectComputeCommand +Class Methods: +Methods: + clearBarrier + concurrentDispatchThreadgroups + concurrentDispatchThreads + reset + setBarrier + setComputePipelineState + setImageblockWidth + setKernelBuffer + setStageInRegion + setThreadgroupMemoryLength +*/ +@(objc_class="MTLIndirectComputeCommand") +IndirectComputeCommand :: struct { using _: NS.Object } + +@(objc_type=IndirectComputeCommand, objc_name="clearBarrier") +IndirectComputeCommand_clearBarrier :: proc(self: ^IndirectComputeCommand) { + msgSend(nil, self, "clearBarrier") +} +@(objc_type=IndirectComputeCommand, objc_name="concurrentDispatchThreadgroups") +IndirectComputeCommand_concurrentDispatchThreadgroups :: proc(self: ^IndirectComputeCommand, threadgroupsPerGrid: Size, threadsPerThreadgroup: Size) { + msgSend(nil, self, "concurrentDispatchThreadgroups:threadsPerThreadgroup:", threadgroupsPerGrid, threadsPerThreadgroup) +} +@(objc_type=IndirectComputeCommand, objc_name="concurrentDispatchThreads") +IndirectComputeCommand_concurrentDispatchThreads :: proc(self: ^IndirectComputeCommand, threadsPerGrid: Size, threadsPerThreadgroup: Size) { + msgSend(nil, self, "concurrentDispatchThreads:threadsPerThreadgroup:", threadsPerGrid, threadsPerThreadgroup) +} +@(objc_type=IndirectComputeCommand, objc_name="reset") +IndirectComputeCommand_reset :: proc(self: ^IndirectComputeCommand) { + msgSend(nil, self, "reset") +} +@(objc_type=IndirectComputeCommand, objc_name="setBarrier") +IndirectComputeCommand_setBarrier :: proc(self: ^IndirectComputeCommand) { + msgSend(nil, self, "setBarrier") +} +@(objc_type=IndirectComputeCommand, objc_name="setComputePipelineState") +IndirectComputeCommand_setComputePipelineState :: proc(self: ^IndirectComputeCommand, pipelineState: ^NS.Object) { + msgSend(nil, self, "setComputePipelineState:", pipelineState) +} +@(objc_type=IndirectComputeCommand, objc_name="setImageblockWidth") +IndirectComputeCommand_setImageblockWidth :: proc(self: ^IndirectComputeCommand, width: ^NS.Object, height: ^NS.Object) { + msgSend(nil, self, "setImageblockWidth:height:", width, height) +} +@(objc_type=IndirectComputeCommand, objc_name="setKernelBuffer") +IndirectComputeCommand_setKernelBuffer :: proc(self: ^IndirectComputeCommand, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setKernelBuffer:offset:atIndex:", buffer, offset, index) +} +@(objc_type=IndirectComputeCommand, objc_name="setStageInRegion") +IndirectComputeCommand_setStageInRegion :: proc(self: ^IndirectComputeCommand, region: Region) { + msgSend(nil, self, "setStageInRegion:", region) +} +@(objc_type=IndirectComputeCommand, objc_name="setThreadgroupMemoryLength") +IndirectComputeCommand_setThreadgroupMemoryLength :: proc(self: ^IndirectComputeCommand, length: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setThreadgroupMemoryLength:atIndex:", length, index) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + IndirectRenderCommand +Class Methods: +Methods: + drawIndexedPatches + drawIndexedPrimitives + drawPatches + drawPrimitives + reset + setFragmentBuffer + setRenderPipelineState + setVertexBuffer +*/ +@(objc_class="MTLIndirectRenderCommand") +IndirectRenderCommand :: struct { using _: NS.Object } + +@(objc_type=IndirectRenderCommand, objc_name="drawIndexedPatches") +IndirectRenderCommand_drawIndexedPatches :: proc(self: ^IndirectRenderCommand, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, controlPointIndexBuffer: ^NS.Object, controlPointIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object, buffer: ^NS.Object, offset: ^NS.Object, instanceStride: ^NS.Object) { + msgSend(nil, self, "drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride) +} +@(objc_type=IndirectRenderCommand, objc_name="drawIndexedPrimitives") +IndirectRenderCommand_drawIndexedPrimitives :: proc(self: ^IndirectRenderCommand, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseVertex: ^NS.Object, baseInstance: ^NS.Object) { + msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount, baseVertex, baseInstance) +} +@(objc_type=IndirectRenderCommand, objc_name="drawPatches") +IndirectRenderCommand_drawPatches :: proc(self: ^IndirectRenderCommand, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object, buffer: ^NS.Object, offset: ^NS.Object, instanceStride: ^NS.Object) { + msgSend(nil, self, "drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride) +} +@(objc_type=IndirectRenderCommand, objc_name="drawPrimitives") +IndirectRenderCommand_drawPrimitives :: proc(self: ^IndirectRenderCommand, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) { + msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:", primitiveType, vertexStart, vertexCount, instanceCount, baseInstance) +} +@(objc_type=IndirectRenderCommand, objc_name="reset") +IndirectRenderCommand_reset :: proc(self: ^IndirectRenderCommand) { + msgSend(nil, self, "reset") +} +@(objc_type=IndirectRenderCommand, objc_name="setFragmentBuffer") +IndirectRenderCommand_setFragmentBuffer :: proc(self: ^IndirectRenderCommand, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setFragmentBuffer:offset:atIndex:", buffer, offset, index) +} +@(objc_type=IndirectRenderCommand, objc_name="setRenderPipelineState") +IndirectRenderCommand_setRenderPipelineState :: proc(self: ^IndirectRenderCommand, pipelineState: ^NS.Object) { + msgSend(nil, self, "setRenderPipelineState:", pipelineState) +} +@(objc_type=IndirectRenderCommand, objc_name="setVertexBuffer") +IndirectRenderCommand_setVertexBuffer :: proc(self: ^IndirectRenderCommand, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setVertexBuffer:offset:atIndex:", buffer, offset, index) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + IntersectionFunctionTable +Class Methods: +Methods: + setBuffer + setBuffers + setFunction + setFunctions + setOpaqueTriangleIntersectionFunctionWithSignature + setOpaqueTriangleIntersectionFunctionWithSignature + setVisibleFunctionTable + setVisibleFunctionTables +*/ +@(objc_class="MTLIntersectionFunctionTable") +IntersectionFunctionTable :: struct { using _: NS.Object } + +@(objc_type=IntersectionFunctionTable, objc_name="setBuffer") +IntersectionFunctionTable_setBuffer :: proc(self: ^IntersectionFunctionTable, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setBuffer:offset:atIndex:", buffer, offset, index) +} +@(objc_type=IntersectionFunctionTable, objc_name="setBuffers") +IntersectionFunctionTable_setBuffers :: proc(self: ^IntersectionFunctionTable, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { + msgSend(nil, self, "setBuffers:offsets:withRange:", buffers, offsets, range) +} +@(objc_type=IntersectionFunctionTable, objc_name="setFunction") +IntersectionFunctionTable_setFunction :: proc(self: ^IntersectionFunctionTable, function: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setFunction:atIndex:", function, index) +} +@(objc_type=IntersectionFunctionTable, objc_name="setFunctions") +IntersectionFunctionTable_setFunctions :: proc(self: ^IntersectionFunctionTable, functions: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setFunctions:withRange:", functions, range) +} +@(objc_type=IntersectionFunctionTable, objc_name="setOpaqueTriangleIntersectionFunctionWithSignature_atIndex_") +IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignature_atIndex_ :: proc(self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, index: ^NS.Object) { + msgSend(nil, self, "setOpaqueTriangleIntersectionFunctionWithSignature:atIndex:", signature, index) +} +@(objc_type=IntersectionFunctionTable, objc_name="setOpaqueTriangleIntersectionFunctionWithSignature_withRange_") +IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignature_withRange_ :: proc(self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, range: NS.Range) { + msgSend(nil, self, "setOpaqueTriangleIntersectionFunctionWithSignature:withRange:", signature, range) +} +@(objc_type=IntersectionFunctionTable, objc_name="setVisibleFunctionTable") +IntersectionFunctionTable_setVisibleFunctionTable :: proc(self: ^IntersectionFunctionTable, visibleFunctionTable: ^NS.Object, bufferIndex: ^NS.Object) { + msgSend(nil, self, "setVisibleFunctionTable:atBufferIndex:", visibleFunctionTable, bufferIndex) +} +@(objc_type=IntersectionFunctionTable, objc_name="setVisibleFunctionTables") +IntersectionFunctionTable_setVisibleFunctionTables :: proc(self: ^IntersectionFunctionTable, visibleFunctionTables: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setVisibleFunctionTables:withBufferRange:", visibleFunctionTables, range) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + Library +Class Methods: +Methods: + device + functionNames + installName + label + newFunctionWithDescriptor + newFunctionWithDescriptor + newFunctionWithName + newFunctionWithName + newFunctionWithName + newIntersectionFunctionWithDescriptor + newIntersectionFunctionWithDescriptor + setLabel + type +*/ +@(objc_class="MTLLibrary") +Library :: struct { using _: NS.Object } + +@(objc_type=Library, objc_name="device") +Library_device :: proc(self: ^Library) -> ^Library { + return msgSend(^Library, self, "device") +} +@(objc_type=Library, objc_name="functionNames") +Library_functionNames :: proc(self: ^Library) -> ^NS.Array { + return msgSend(^NS.Array, self, "functionNames") +} +@(objc_type=Library, objc_name="installName") +Library_installName :: proc(self: ^Library) -> ^NS.String { + return msgSend(^NS.String, self, "installName") +} +@(objc_type=Library, objc_name="label") +Library_label :: proc(self: ^Library) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=Library, objc_name="newFunctionWithDescriptor_completionHandler_") +Library_newFunctionWithDescriptor_completionHandler_ :: proc(self: ^Library, descriptor: ^FunctionDescriptor, completionHandler: rawptr) { + msgSend(nil, self, "newFunctionWithDescriptor:completionHandler:", descriptor, completionHandler) +} +@(objc_type=Library, objc_name="newFunctionWithDescriptor_error_") +Library_newFunctionWithDescriptor_error_ :: proc(self: ^Library, descriptor: ^FunctionDescriptor, error: ^^NS.Error ) -> ^Library { + return msgSend(^Library, self, "newFunctionWithDescriptor:error:", descriptor, error) +} +@(objc_type=Library, objc_name="newFunctionWithName") +Library_newFunctionWithName :: proc(self: ^Library, functionName: ^NS.String) -> ^Library { + return msgSend(^Library, self, "newFunctionWithName:", functionName) +} +@(objc_type=Library, objc_name="newFunctionWithName_constantValues_completionHandler_") +Library_newFunctionWithName_constantValues_completionHandler_ :: proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues, completionHandler: rawptr) { + msgSend(nil, self, "newFunctionWithName:constantValues:completionHandler:", name, constantValues, completionHandler) +} +@(objc_type=Library, objc_name="newFunctionWithName_constantValues_error_") +Library_newFunctionWithName_constantValues_error_ :: proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues, error: ^^NS.Error ) -> ^Library { + return msgSend(^Library, self, "newFunctionWithName:constantValues:error:", name, constantValues, error) +} +@(objc_type=Library, objc_name="newIntersectionFunctionWithDescriptor_completionHandler_") +Library_newIntersectionFunctionWithDescriptor_completionHandler_ :: proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor, completionHandler: rawptr) { + msgSend(nil, self, "newIntersectionFunctionWithDescriptor:completionHandler:", descriptor, completionHandler) +} +@(objc_type=Library, objc_name="newIntersectionFunctionWithDescriptor_error_") +Library_newIntersectionFunctionWithDescriptor_error_ :: proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor, error: ^^NS.Error ) -> ^Library { + return msgSend(^Library, self, "newIntersectionFunctionWithDescriptor:error:", descriptor, error) +} +@(objc_type=Library, objc_name="setLabel") +Library_setLabel :: proc(self: ^Library, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} +@(objc_type=Library, objc_name="type") +Library_type :: proc(self: ^Library) -> LibraryType { + return msgSend(LibraryType, self, "type") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + ParallelRenderCommandEncoder +Class Methods: +Methods: + renderCommandEncoder + setColorStoreAction + setColorStoreActionOptions + setDepthStoreAction + setDepthStoreActionOptions + setStencilStoreAction + setStencilStoreActionOptions +*/ +@(objc_class="MTLParallelRenderCommandEncoder") +ParallelRenderCommandEncoder :: struct { using _: NS.Object } + +@(objc_type=ParallelRenderCommandEncoder, objc_name="renderCommandEncoder") +ParallelRenderCommandEncoder_renderCommandEncoder :: proc(self: ^ParallelRenderCommandEncoder) -> ^ParallelRenderCommandEncoder { + return msgSend(^ParallelRenderCommandEncoder, self, "renderCommandEncoder") +} +@(objc_type=ParallelRenderCommandEncoder, objc_name="setColorStoreAction") +ParallelRenderCommandEncoder_setColorStoreAction :: proc(self: ^ParallelRenderCommandEncoder, storeAction: StoreAction, colorAttachmentIndex: ^NS.Object) { + msgSend(nil, self, "setColorStoreAction:atIndex:", storeAction, colorAttachmentIndex) +} +@(objc_type=ParallelRenderCommandEncoder, objc_name="setColorStoreActionOptions") +ParallelRenderCommandEncoder_setColorStoreActionOptions :: proc(self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions, colorAttachmentIndex: ^NS.Object) { + msgSend(nil, self, "setColorStoreActionOptions:atIndex:", storeActionOptions, colorAttachmentIndex) +} +@(objc_type=ParallelRenderCommandEncoder, objc_name="setDepthStoreAction") +ParallelRenderCommandEncoder_setDepthStoreAction :: proc(self: ^ParallelRenderCommandEncoder, storeAction: StoreAction) { + msgSend(nil, self, "setDepthStoreAction:", storeAction) +} +@(objc_type=ParallelRenderCommandEncoder, objc_name="setDepthStoreActionOptions") +ParallelRenderCommandEncoder_setDepthStoreActionOptions :: proc(self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions) { + msgSend(nil, self, "setDepthStoreActionOptions:", storeActionOptions) +} +@(objc_type=ParallelRenderCommandEncoder, objc_name="setStencilStoreAction") +ParallelRenderCommandEncoder_setStencilStoreAction :: proc(self: ^ParallelRenderCommandEncoder, storeAction: StoreAction) { + msgSend(nil, self, "setStencilStoreAction:", storeAction) +} +@(objc_type=ParallelRenderCommandEncoder, objc_name="setStencilStoreActionOptions") +ParallelRenderCommandEncoder_setStencilStoreActionOptions :: proc(self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions) { + msgSend(nil, self, "setStencilStoreActionOptions:", storeActionOptions) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + RasterizationRateMap +Class Methods: +Methods: + copyParameterDataToBuffer + device + label + layerCount + mapPhysicalToScreenCoordinates + mapScreenToPhysicalCoordinates + parameterBufferSizeAndAlign + physicalGranularity + physicalSizeForLayer + screenSize +*/ +@(objc_class="MTLRasterizationRateMap") +RasterizationRateMap :: struct { using _: NS.Object } + +@(objc_type=RasterizationRateMap, objc_name="copyParameterDataToBuffer") +RasterizationRateMap_copyParameterDataToBuffer :: proc(self: ^RasterizationRateMap, buffer: ^NS.Object, offset: ^NS.Object) { + msgSend(nil, self, "copyParameterDataToBuffer:offset:", buffer, offset) +} +@(objc_type=RasterizationRateMap, objc_name="device") +RasterizationRateMap_device :: proc(self: ^RasterizationRateMap) -> ^RasterizationRateMap { + return msgSend(^RasterizationRateMap, self, "device") +} +@(objc_type=RasterizationRateMap, objc_name="label") +RasterizationRateMap_label :: proc(self: ^RasterizationRateMap) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=RasterizationRateMap, objc_name="layerCount") +RasterizationRateMap_layerCount :: proc(self: ^RasterizationRateMap) -> NS.Integer { + return msgSend(NS.Integer, self, "layerCount") +} +@(objc_type=RasterizationRateMap, objc_name="mapPhysicalToScreenCoordinates") +RasterizationRateMap_mapPhysicalToScreenCoordinates :: proc(self: ^RasterizationRateMap, physicalCoordinates: Coordinate2D, layerIndex: ^NS.Object) -> Coordinate2D { + return msgSend(Coordinate2D, self, "mapPhysicalToScreenCoordinates:forLayer:", physicalCoordinates, layerIndex) +} +@(objc_type=RasterizationRateMap, objc_name="mapScreenToPhysicalCoordinates") +RasterizationRateMap_mapScreenToPhysicalCoordinates :: proc(self: ^RasterizationRateMap, screenCoordinates: Coordinate2D, layerIndex: ^NS.Object) -> Coordinate2D { + return msgSend(Coordinate2D, self, "mapScreenToPhysicalCoordinates:forLayer:", screenCoordinates, layerIndex) +} +@(objc_type=RasterizationRateMap, objc_name="parameterBufferSizeAndAlign") +RasterizationRateMap_parameterBufferSizeAndAlign :: proc(self: ^RasterizationRateMap) -> SizeAndAlign { + return msgSend(SizeAndAlign, self, "parameterBufferSizeAndAlign") +} +@(objc_type=RasterizationRateMap, objc_name="physicalGranularity") +RasterizationRateMap_physicalGranularity :: proc(self: ^RasterizationRateMap) -> Size { + return msgSend(Size, self, "physicalGranularity") +} +@(objc_type=RasterizationRateMap, objc_name="physicalSizeForLayer") +RasterizationRateMap_physicalSizeForLayer :: proc(self: ^RasterizationRateMap, layerIndex: ^NS.Object) -> Size { + return msgSend(Size, self, "physicalSizeForLayer:", layerIndex) +} +@(objc_type=RasterizationRateMap, objc_name="screenSize") +RasterizationRateMap_screenSize :: proc(self: ^RasterizationRateMap) -> Size { + return msgSend(Size, self, "screenSize") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + RenderCommandEncoder +Class Methods: +Methods: + dispatchThreadsPerTile + drawIndexedPatches + drawIndexedPatches + drawIndexedPrimitives + drawIndexedPrimitives + drawIndexedPrimitives + drawIndexedPrimitives + drawPatches + drawPatches + drawPrimitives + drawPrimitives + drawPrimitives + drawPrimitives + executeCommandsInBuffer + executeCommandsInBuffer + memoryBarrierWithResources + memoryBarrierWithScope + sampleCountersInBuffer + setBlendColorRed + setColorStoreAction + setColorStoreActionOptions + setCullMode + setDepthBias + setDepthClipMode + setDepthStencilState + setDepthStoreAction + setDepthStoreActionOptions + setFragmentBuffer + setFragmentBufferOffset + setFragmentBuffers + setFragmentBytes + setFragmentSamplerState + setFragmentSamplerState + setFragmentSamplerStates + setFragmentSamplerStates + setFragmentTexture + setFragmentTextures + setFrontFacingWinding + setRenderPipelineState + setScissorRect + setScissorRects + setStencilFrontReferenceValue + setStencilReferenceValue + setStencilStoreAction + setStencilStoreActionOptions + setTessellationFactorBuffer + setTessellationFactorScale + setThreadgroupMemoryLength + setTileBuffer + setTileBufferOffset + setTileBuffers + setTileBytes + setTileSamplerState + setTileSamplerState + setTileSamplerStates + setTileSamplerStates + setTileTexture + setTileTextures + setTriangleFillMode + setVertexAmplificationCount + setVertexBuffer + setVertexBufferOffset + setVertexBuffers + setVertexBytes + setVertexSamplerState + setVertexSamplerState + setVertexSamplerStates + setVertexSamplerStates + setVertexTexture + setVertexTextures + setViewport + setViewports + setVisibilityResultMode + textureBarrier + tileHeight + tileWidth + updateFence + useHeap + useHeap + useHeaps + useHeaps + useResource + useResource + useResources + useResources + waitForFence +*/ +@(objc_class="MTLRenderCommandEncoder") +RenderCommandEncoder :: struct { using _: NS.Object } + +@(objc_type=RenderCommandEncoder, objc_name="dispatchThreadsPerTile") +RenderCommandEncoder_dispatchThreadsPerTile :: proc(self: ^RenderCommandEncoder, threadsPerTile: Size) { + msgSend(nil, self, "dispatchThreadsPerTile:", threadsPerTile) +} +@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPatches_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_indirectBuffer_indirectBufferOffset_") +RenderCommandEncoder_drawIndexedPatches_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_indirectBuffer_indirectBufferOffset_ :: proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, controlPointIndexBuffer: ^NS.Object, controlPointIndexBufferOffset: ^NS.Object, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { + msgSend(nil, self, "drawIndexedPatches:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:indirectBuffer:indirectBufferOffset:", numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, indirectBuffer, indirectBufferOffset) +} +@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_") +RenderCommandEncoder_drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_ :: proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, controlPointIndexBuffer: ^NS.Object, controlPointIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) { + msgSend(nil, self, "drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, instanceCount, baseInstance) +} +@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_") +RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object) { + msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset) +} +@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_") +RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, instanceCount: ^NS.Object) { + msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount) +} +@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_") +RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseVertex: ^NS.Object, baseInstance: ^NS.Object) { + msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount, baseVertex, baseInstance) +} +@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexType_indexBuffer_indexBufferOffset_indirectBuffer_indirectBufferOffset_") +RenderCommandEncoder_drawIndexedPrimitives_indexType_indexBuffer_indexBufferOffset_indirectBuffer_indirectBufferOffset_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { + msgSend(nil, self, "drawIndexedPrimitives:indexType:indexBuffer:indexBufferOffset:indirectBuffer:indirectBufferOffset:", primitiveType, indexType, indexBuffer, indexBufferOffset, indirectBuffer, indirectBufferOffset) +} +@(objc_type=RenderCommandEncoder, objc_name="drawPatches_patchIndexBuffer_patchIndexBufferOffset_indirectBuffer_indirectBufferOffset_") +RenderCommandEncoder_drawPatches_patchIndexBuffer_patchIndexBufferOffset_indirectBuffer_indirectBufferOffset_ :: proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { + msgSend(nil, self, "drawPatches:patchIndexBuffer:patchIndexBufferOffset:indirectBuffer:indirectBufferOffset:", numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, indirectBuffer, indirectBufferOffset) +} +@(objc_type=RenderCommandEncoder, objc_name="drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_") +RenderCommandEncoder_drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_ :: proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) { + msgSend(nil, self, "drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance) +} +@(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_indirectBuffer_indirectBufferOffset_") +RenderCommandEncoder_drawPrimitives_indirectBuffer_indirectBufferOffset_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { + msgSend(nil, self, "drawPrimitives:indirectBuffer:indirectBufferOffset:", primitiveType, indirectBuffer, indirectBufferOffset) +} +@(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_vertexStart_vertexCount_") +RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object) { + msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:", primitiveType, vertexStart, vertexCount) +} +@(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_vertexStart_vertexCount_instanceCount_") +RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_instanceCount_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object, instanceCount: ^NS.Object) { + msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:instanceCount:", primitiveType, vertexStart, vertexCount, instanceCount) +} +@(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_") +RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) { + msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:", primitiveType, vertexStart, vertexCount, instanceCount, baseInstance) +} +@(objc_type=RenderCommandEncoder, objc_name="executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_") +RenderCommandEncoder_executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_ :: proc(self: ^RenderCommandEncoder, indirectCommandbuffer: ^NS.Object, indirectRangeBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { + msgSend(nil, self, "executeCommandsInBuffer:indirectBuffer:indirectBufferOffset:", indirectCommandbuffer, indirectRangeBuffer, indirectBufferOffset) +} +@(objc_type=RenderCommandEncoder, objc_name="executeCommandsInBuffer_withRange_") +RenderCommandEncoder_executeCommandsInBuffer_withRange_ :: proc(self: ^RenderCommandEncoder, indirectCommandBuffer: ^NS.Object, executionRange: NS.Range) { + msgSend(nil, self, "executeCommandsInBuffer:withRange:", indirectCommandBuffer, executionRange) +} +@(objc_type=RenderCommandEncoder, objc_name="memoryBarrierWithResources") +RenderCommandEncoder_memoryBarrierWithResources :: proc(self: ^RenderCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, after: RenderStages, before: RenderStages) { + msgSend(nil, self, "memoryBarrierWithResources:count:afterStages:beforeStages:", resources, count, after, before) +} +@(objc_type=RenderCommandEncoder, objc_name="memoryBarrierWithScope") +RenderCommandEncoder_memoryBarrierWithScope :: proc(self: ^RenderCommandEncoder, scope: BarrierScope, after: RenderStages, before: RenderStages) { + msgSend(nil, self, "memoryBarrierWithScope:afterStages:beforeStages:", scope, after, before) +} +@(objc_type=RenderCommandEncoder, objc_name="sampleCountersInBuffer") +RenderCommandEncoder_sampleCountersInBuffer :: proc(self: ^RenderCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) { + msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier) +} +@(objc_type=RenderCommandEncoder, objc_name="setBlendColorRed") +RenderCommandEncoder_setBlendColorRed :: proc(self: ^RenderCommandEncoder, red: f32, green: f32, blue: f32, alpha: f32) { + msgSend(nil, self, "setBlendColorRed:green:blue:alpha:", red, green, blue, alpha) +} +@(objc_type=RenderCommandEncoder, objc_name="setColorStoreAction") +RenderCommandEncoder_setColorStoreAction :: proc(self: ^RenderCommandEncoder, storeAction: StoreAction, colorAttachmentIndex: ^NS.Object) { + msgSend(nil, self, "setColorStoreAction:atIndex:", storeAction, colorAttachmentIndex) +} +@(objc_type=RenderCommandEncoder, objc_name="setColorStoreActionOptions") +RenderCommandEncoder_setColorStoreActionOptions :: proc(self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions, colorAttachmentIndex: ^NS.Object) { + msgSend(nil, self, "setColorStoreActionOptions:atIndex:", storeActionOptions, colorAttachmentIndex) +} +@(objc_type=RenderCommandEncoder, objc_name="setCullMode") +RenderCommandEncoder_setCullMode :: proc(self: ^RenderCommandEncoder, cullMode: CullMode) { + msgSend(nil, self, "setCullMode:", cullMode) +} +@(objc_type=RenderCommandEncoder, objc_name="setDepthBias") +RenderCommandEncoder_setDepthBias :: proc(self: ^RenderCommandEncoder, depthBias: f32, slopeScale: f32, clamp: f32) { + msgSend(nil, self, "setDepthBias:slopeScale:clamp:", depthBias, slopeScale, clamp) +} +@(objc_type=RenderCommandEncoder, objc_name="setDepthClipMode") +RenderCommandEncoder_setDepthClipMode :: proc(self: ^RenderCommandEncoder, depthClipMode: DepthClipMode) { + msgSend(nil, self, "setDepthClipMode:", depthClipMode) +} +@(objc_type=RenderCommandEncoder, objc_name="setDepthStencilState") +RenderCommandEncoder_setDepthStencilState :: proc(self: ^RenderCommandEncoder, depthStencilState: ^NS.Object) { + msgSend(nil, self, "setDepthStencilState:", depthStencilState) +} +@(objc_type=RenderCommandEncoder, objc_name="setDepthStoreAction") +RenderCommandEncoder_setDepthStoreAction :: proc(self: ^RenderCommandEncoder, storeAction: StoreAction) { + msgSend(nil, self, "setDepthStoreAction:", storeAction) +} +@(objc_type=RenderCommandEncoder, objc_name="setDepthStoreActionOptions") +RenderCommandEncoder_setDepthStoreActionOptions :: proc(self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions) { + msgSend(nil, self, "setDepthStoreActionOptions:", storeActionOptions) +} +@(objc_type=RenderCommandEncoder, objc_name="setFragmentBuffer") +RenderCommandEncoder_setFragmentBuffer :: proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setFragmentBuffer:offset:atIndex:", buffer, offset, index) +} +@(objc_type=RenderCommandEncoder, objc_name="setFragmentBufferOffset") +RenderCommandEncoder_setFragmentBufferOffset :: proc(self: ^RenderCommandEncoder, offset: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setFragmentBufferOffset:atIndex:", offset, index) +} +@(objc_type=RenderCommandEncoder, objc_name="setFragmentBuffers") +RenderCommandEncoder_setFragmentBuffers :: proc(self: ^RenderCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { + msgSend(nil, self, "setFragmentBuffers:offsets:withRange:", buffers, offsets, range) +} +@(objc_type=RenderCommandEncoder, objc_name="setFragmentBytes") +RenderCommandEncoder_setFragmentBytes :: proc(self: ^RenderCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setFragmentBytes:length:atIndex:", bytes, length, index) +} +@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerState_atIndex_") +RenderCommandEncoder_setFragmentSamplerState_atIndex_ :: proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setFragmentSamplerState:atIndex:", sampler, index) +} +@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerState_lodMinClamp_lodMaxClamp_atIndex_") +RenderCommandEncoder_setFragmentSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) { + msgSend(nil, self, "setFragmentSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) +} +@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStates_lodMinClamps_lodMaxClamps_withRange_") +RenderCommandEncoder_setFragmentSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { + msgSend(nil, self, "setFragmentSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range) +} +@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStates_withRange_") +RenderCommandEncoder_setFragmentSamplerStates_withRange_ :: proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setFragmentSamplerStates:withRange:", samplers, range) +} +@(objc_type=RenderCommandEncoder, objc_name="setFragmentTexture") +RenderCommandEncoder_setFragmentTexture :: proc(self: ^RenderCommandEncoder, texture: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setFragmentTexture:atIndex:", texture, index) +} +@(objc_type=RenderCommandEncoder, objc_name="setFragmentTextures") +RenderCommandEncoder_setFragmentTextures :: proc(self: ^RenderCommandEncoder, textures: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setFragmentTextures:withRange:", textures, range) +} +@(objc_type=RenderCommandEncoder, objc_name="setFrontFacingWinding") +RenderCommandEncoder_setFrontFacingWinding :: proc(self: ^RenderCommandEncoder, frontFacingWinding: Winding) { + msgSend(nil, self, "setFrontFacingWinding:", frontFacingWinding) +} +@(objc_type=RenderCommandEncoder, objc_name="setRenderPipelineState") +RenderCommandEncoder_setRenderPipelineState :: proc(self: ^RenderCommandEncoder, pipelineState: ^NS.Object) { + msgSend(nil, self, "setRenderPipelineState:", pipelineState) +} +@(objc_type=RenderCommandEncoder, objc_name="setScissorRect") +RenderCommandEncoder_setScissorRect :: proc(self: ^RenderCommandEncoder, rect: ScissorRect) { + msgSend(nil, self, "setScissorRect:", rect) +} +@(objc_type=RenderCommandEncoder, objc_name="setScissorRects") +RenderCommandEncoder_setScissorRects :: proc(self: ^RenderCommandEncoder, scissorRects: ^ScissorRect, count: ^NS.Object) { + msgSend(nil, self, "setScissorRects:count:", scissorRects, count) +} +@(objc_type=RenderCommandEncoder, objc_name="setStencilFrontReferenceValue") +RenderCommandEncoder_setStencilFrontReferenceValue :: proc(self: ^RenderCommandEncoder, frontReferenceValue: u32, backReferenceValue: u32) { + msgSend(nil, self, "setStencilFrontReferenceValue:backReferenceValue:", frontReferenceValue, backReferenceValue) +} +@(objc_type=RenderCommandEncoder, objc_name="setStencilReferenceValue") +RenderCommandEncoder_setStencilReferenceValue :: proc(self: ^RenderCommandEncoder, referenceValue: u32) { + msgSend(nil, self, "setStencilReferenceValue:", referenceValue) +} +@(objc_type=RenderCommandEncoder, objc_name="setStencilStoreAction") +RenderCommandEncoder_setStencilStoreAction :: proc(self: ^RenderCommandEncoder, storeAction: StoreAction) { + msgSend(nil, self, "setStencilStoreAction:", storeAction) +} +@(objc_type=RenderCommandEncoder, objc_name="setStencilStoreActionOptions") +RenderCommandEncoder_setStencilStoreActionOptions :: proc(self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions) { + msgSend(nil, self, "setStencilStoreActionOptions:", storeActionOptions) +} +@(objc_type=RenderCommandEncoder, objc_name="setTessellationFactorBuffer") +RenderCommandEncoder_setTessellationFactorBuffer :: proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, instanceStride: ^NS.Object) { + msgSend(nil, self, "setTessellationFactorBuffer:offset:instanceStride:", buffer, offset, instanceStride) +} +@(objc_type=RenderCommandEncoder, objc_name="setTessellationFactorScale") +RenderCommandEncoder_setTessellationFactorScale :: proc(self: ^RenderCommandEncoder, scale: f32) { + msgSend(nil, self, "setTessellationFactorScale:", scale) +} +@(objc_type=RenderCommandEncoder, objc_name="setThreadgroupMemoryLength") +RenderCommandEncoder_setThreadgroupMemoryLength :: proc(self: ^RenderCommandEncoder, length: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setThreadgroupMemoryLength:offset:atIndex:", length, offset, index) +} +@(objc_type=RenderCommandEncoder, objc_name="setTileBuffer") +RenderCommandEncoder_setTileBuffer :: proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setTileBuffer:offset:atIndex:", buffer, offset, index) +} +@(objc_type=RenderCommandEncoder, objc_name="setTileBufferOffset") +RenderCommandEncoder_setTileBufferOffset :: proc(self: ^RenderCommandEncoder, offset: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setTileBufferOffset:atIndex:", offset, index) +} +@(objc_type=RenderCommandEncoder, objc_name="setTileBuffers") +RenderCommandEncoder_setTileBuffers :: proc(self: ^RenderCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { + msgSend(nil, self, "setTileBuffers:offsets:withRange:", buffers, offsets, range) +} +@(objc_type=RenderCommandEncoder, objc_name="setTileBytes") +RenderCommandEncoder_setTileBytes :: proc(self: ^RenderCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setTileBytes:length:atIndex:", bytes, length, index) +} +@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerState_atIndex_") +RenderCommandEncoder_setTileSamplerState_atIndex_ :: proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setTileSamplerState:atIndex:", sampler, index) +} +@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerState_lodMinClamp_lodMaxClamp_atIndex_") +RenderCommandEncoder_setTileSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) { + msgSend(nil, self, "setTileSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) +} +@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerStates_lodMinClamps_lodMaxClamps_withRange_") +RenderCommandEncoder_setTileSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { + msgSend(nil, self, "setTileSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range) +} +@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerStates_withRange_") +RenderCommandEncoder_setTileSamplerStates_withRange_ :: proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setTileSamplerStates:withRange:", samplers, range) +} +@(objc_type=RenderCommandEncoder, objc_name="setTileTexture") +RenderCommandEncoder_setTileTexture :: proc(self: ^RenderCommandEncoder, texture: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setTileTexture:atIndex:", texture, index) +} +@(objc_type=RenderCommandEncoder, objc_name="setTileTextures") +RenderCommandEncoder_setTileTextures :: proc(self: ^RenderCommandEncoder, textures: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setTileTextures:withRange:", textures, range) +} +@(objc_type=RenderCommandEncoder, objc_name="setTriangleFillMode") +RenderCommandEncoder_setTriangleFillMode :: proc(self: ^RenderCommandEncoder, fillMode: TriangleFillMode) { + msgSend(nil, self, "setTriangleFillMode:", fillMode) +} +@(objc_type=RenderCommandEncoder, objc_name="setVertexAmplificationCount") +RenderCommandEncoder_setVertexAmplificationCount :: proc(self: ^RenderCommandEncoder, count: ^NS.Object, viewMappings: ^VertexAmplificationViewMapping) { + msgSend(nil, self, "setVertexAmplificationCount:viewMappings:", count, viewMappings) +} +@(objc_type=RenderCommandEncoder, objc_name="setVertexBuffer") +RenderCommandEncoder_setVertexBuffer :: proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setVertexBuffer:offset:atIndex:", buffer, offset, index) +} +@(objc_type=RenderCommandEncoder, objc_name="setVertexBufferOffset") +RenderCommandEncoder_setVertexBufferOffset :: proc(self: ^RenderCommandEncoder, offset: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setVertexBufferOffset:atIndex:", offset, index) +} +@(objc_type=RenderCommandEncoder, objc_name="setVertexBuffers") +RenderCommandEncoder_setVertexBuffers :: proc(self: ^RenderCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { + msgSend(nil, self, "setVertexBuffers:offsets:withRange:", buffers, offsets, range) +} +@(objc_type=RenderCommandEncoder, objc_name="setVertexBytes") +RenderCommandEncoder_setVertexBytes :: proc(self: ^RenderCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setVertexBytes:length:atIndex:", bytes, length, index) +} +@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerState_atIndex_") +RenderCommandEncoder_setVertexSamplerState_atIndex_ :: proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setVertexSamplerState:atIndex:", sampler, index) +} +@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerState_lodMinClamp_lodMaxClamp_atIndex_") +RenderCommandEncoder_setVertexSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) { + msgSend(nil, self, "setVertexSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) +} +@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerStates_lodMinClamps_lodMaxClamps_withRange_") +RenderCommandEncoder_setVertexSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { + msgSend(nil, self, "setVertexSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range) +} +@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerStates_withRange_") +RenderCommandEncoder_setVertexSamplerStates_withRange_ :: proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setVertexSamplerStates:withRange:", samplers, range) +} +@(objc_type=RenderCommandEncoder, objc_name="setVertexTexture") +RenderCommandEncoder_setVertexTexture :: proc(self: ^RenderCommandEncoder, texture: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setVertexTexture:atIndex:", texture, index) +} +@(objc_type=RenderCommandEncoder, objc_name="setVertexTextures") +RenderCommandEncoder_setVertexTextures :: proc(self: ^RenderCommandEncoder, textures: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setVertexTextures:withRange:", textures, range) +} +@(objc_type=RenderCommandEncoder, objc_name="setViewport") +RenderCommandEncoder_setViewport :: proc(self: ^RenderCommandEncoder, viewport: Viewport) { + msgSend(nil, self, "setViewport:", viewport) +} +@(objc_type=RenderCommandEncoder, objc_name="setViewports") +RenderCommandEncoder_setViewports :: proc(self: ^RenderCommandEncoder, viewports: ^Viewport, count: ^NS.Object) { + msgSend(nil, self, "setViewports:count:", viewports, count) +} +@(objc_type=RenderCommandEncoder, objc_name="setVisibilityResultMode") +RenderCommandEncoder_setVisibilityResultMode :: proc(self: ^RenderCommandEncoder, mode: VisibilityResultMode, offset: ^NS.Object) { + msgSend(nil, self, "setVisibilityResultMode:offset:", mode, offset) +} +@(objc_type=RenderCommandEncoder, objc_name="textureBarrier") +RenderCommandEncoder_textureBarrier :: proc(self: ^RenderCommandEncoder) { + msgSend(nil, self, "textureBarrier") +} +@(objc_type=RenderCommandEncoder, objc_name="tileHeight") +RenderCommandEncoder_tileHeight :: proc(self: ^RenderCommandEncoder) -> NS.Integer { + return msgSend(NS.Integer, self, "tileHeight") +} +@(objc_type=RenderCommandEncoder, objc_name="tileWidth") +RenderCommandEncoder_tileWidth :: proc(self: ^RenderCommandEncoder) -> NS.Integer { + return msgSend(NS.Integer, self, "tileWidth") +} +@(objc_type=RenderCommandEncoder, objc_name="updateFence") +RenderCommandEncoder_updateFence :: proc(self: ^RenderCommandEncoder, fence: ^NS.Object, stages: RenderStages) { + msgSend(nil, self, "updateFence:afterStages:", fence, stages) +} +@(objc_type=RenderCommandEncoder, objc_name="useHeap") +RenderCommandEncoder_useHeap :: proc(self: ^RenderCommandEncoder, heap: ^NS.Object) { + msgSend(nil, self, "useHeap:", heap) +} +@(objc_type=RenderCommandEncoder, objc_name="useHeap_stages_") +RenderCommandEncoder_useHeap_stages_ :: proc(self: ^RenderCommandEncoder, heap: ^NS.Object, stages: RenderStages) { + msgSend(nil, self, "useHeap:stages:", heap, stages) +} +@(objc_type=RenderCommandEncoder, objc_name="useHeaps") +RenderCommandEncoder_useHeaps :: proc(self: ^RenderCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object) { + msgSend(nil, self, "useHeaps:count:", heaps, count) +} +@(objc_type=RenderCommandEncoder, objc_name="useHeaps_count_stages_") +RenderCommandEncoder_useHeaps_count_stages_ :: proc(self: ^RenderCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object, stages: RenderStages) { + msgSend(nil, self, "useHeaps:count:stages:", heaps, count, stages) +} +@(objc_type=RenderCommandEncoder, objc_name="useResource") +RenderCommandEncoder_useResource :: proc(self: ^RenderCommandEncoder, resource: ^NS.Object, usage: ResourceUsage) { + msgSend(nil, self, "useResource:usage:", resource, usage) +} +@(objc_type=RenderCommandEncoder, objc_name="useResource_usage_stages_") +RenderCommandEncoder_useResource_usage_stages_ :: proc(self: ^RenderCommandEncoder, resource: ^NS.Object, usage: ResourceUsage, stages: RenderStages) { + msgSend(nil, self, "useResource:usage:stages:", resource, usage, stages) +} +@(objc_type=RenderCommandEncoder, objc_name="useResources") +RenderCommandEncoder_useResources :: proc(self: ^RenderCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage) { + msgSend(nil, self, "useResources:count:usage:", resources, count, usage) +} +@(objc_type=RenderCommandEncoder, objc_name="useResources_count_usage_stages_") +RenderCommandEncoder_useResources_count_usage_stages_ :: proc(self: ^RenderCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage, stages: RenderStages) { + msgSend(nil, self, "useResources:count:usage:stages:", resources, count, usage, stages) +} +@(objc_type=RenderCommandEncoder, objc_name="waitForFence") +RenderCommandEncoder_waitForFence :: proc(self: ^RenderCommandEncoder, fence: ^NS.Object, stages: RenderStages) { + msgSend(nil, self, "waitForFence:beforeStages:", fence, stages) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + RenderPipelineState +Class Methods: +Methods: + device + imageblockMemoryLengthForDimensions + imageblockSampleLength + label + maxTotalThreadsPerThreadgroup + supportIndirectCommandBuffers + threadgroupSizeMatchesTileSize +*/ +@(objc_class="MTLRenderPipelineState") +RenderPipelineState :: struct { using _: NS.Object } + +@(objc_type=RenderPipelineState, objc_name="device") +RenderPipelineState_device :: proc(self: ^RenderPipelineState) -> ^RenderPipelineState { + return msgSend(^RenderPipelineState, self, "device") +} +@(objc_type=RenderPipelineState, objc_name="imageblockMemoryLengthForDimensions") +RenderPipelineState_imageblockMemoryLengthForDimensions :: proc(self: ^RenderPipelineState, imageblockDimensions: Size) -> ^RenderPipelineState { + return msgSend(^RenderPipelineState, self, "imageblockMemoryLengthForDimensions:", imageblockDimensions) +} +@(objc_type=RenderPipelineState, objc_name="imageblockSampleLength") +RenderPipelineState_imageblockSampleLength :: proc(self: ^RenderPipelineState) -> NS.Integer { + return msgSend(NS.Integer, self, "imageblockSampleLength") +} +@(objc_type=RenderPipelineState, objc_name="label") +RenderPipelineState_label :: proc(self: ^RenderPipelineState) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=RenderPipelineState, objc_name="maxTotalThreadsPerThreadgroup") +RenderPipelineState_maxTotalThreadsPerThreadgroup :: proc(self: ^RenderPipelineState) -> NS.Integer { + return msgSend(NS.Integer, self, "maxTotalThreadsPerThreadgroup") +} +@(objc_type=RenderPipelineState, objc_name="supportIndirectCommandBuffers") +RenderPipelineState_supportIndirectCommandBuffers :: proc(self: ^RenderPipelineState) -> BOOL { + return msgSend(BOOL, self, "supportIndirectCommandBuffers") +} +@(objc_type=RenderPipelineState, objc_name="threadgroupSizeMatchesTileSize") +RenderPipelineState_threadgroupSizeMatchesTileSize :: proc(self: ^RenderPipelineState) -> BOOL { + return msgSend(BOOL, self, "threadgroupSizeMatchesTileSize") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + Resource +Class Methods: +Methods: + allocatedSize + cpuCacheMode + device + hazardTrackingMode + heap + heapOffset + isAliasable + label + makeAliasable + resourceOptions + setLabel + setPurgeableState + storageMode +*/ +@(objc_class="MTLResource") +Resource :: struct { using _: NS.Object } + +@(objc_type=Resource, objc_name="allocatedSize") +Resource_allocatedSize :: proc(self: ^Resource) -> NS.Integer { + return msgSend(NS.Integer, self, "allocatedSize") +} +@(objc_type=Resource, objc_name="cpuCacheMode") +Resource_cpuCacheMode :: proc(self: ^Resource) -> CPUCacheMode { + return msgSend(CPUCacheMode, self, "cpuCacheMode") +} +@(objc_type=Resource, objc_name="device") +Resource_device :: proc(self: ^Resource) -> ^Resource { + return msgSend(^Resource, self, "device") +} +@(objc_type=Resource, objc_name="hazardTrackingMode") +Resource_hazardTrackingMode :: proc(self: ^Resource) -> HazardTrackingMode { + return msgSend(HazardTrackingMode, self, "hazardTrackingMode") +} +@(objc_type=Resource, objc_name="heap") +Resource_heap :: proc(self: ^Resource) -> ^Resource { + return msgSend(^Resource, self, "heap") +} +@(objc_type=Resource, objc_name="heapOffset") +Resource_heapOffset :: proc(self: ^Resource) -> NS.Integer { + return msgSend(NS.Integer, self, "heapOffset") +} +@(objc_type=Resource, objc_name="isAliasable") +Resource_isAliasable :: proc(self: ^Resource) -> BOOL { + return msgSend(BOOL, self, "isAliasable") +} +@(objc_type=Resource, objc_name="label") +Resource_label :: proc(self: ^Resource) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} +@(objc_type=Resource, objc_name="makeAliasable") +Resource_makeAliasable :: proc(self: ^Resource) { + msgSend(nil, self, "makeAliasable") +} +@(objc_type=Resource, objc_name="resourceOptions") +Resource_resourceOptions :: proc(self: ^Resource) -> ResourceOptions { + return msgSend(ResourceOptions, self, "resourceOptions") +} +@(objc_type=Resource, objc_name="setLabel") +Resource_setLabel :: proc(self: ^Resource, label: ^NS.String) { + msgSend(nil, self, "setLabel:", label) +} +@(objc_type=Resource, objc_name="setPurgeableState") +Resource_setPurgeableState :: proc(self: ^Resource, state: PurgeableState) -> PurgeableState { + return msgSend(PurgeableState, self, "setPurgeableState:", state) +} +@(objc_type=Resource, objc_name="storageMode") +Resource_storageMode :: proc(self: ^Resource) -> StorageMode { + return msgSend(StorageMode, self, "storageMode") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + ResourceStateCommandEncoder +Class Methods: +Methods: + updateFence + updateTextureMapping + updateTextureMapping + updateTextureMappings + waitForFence +*/ +@(objc_class="MTLResourceStateCommandEncoder") +ResourceStateCommandEncoder :: struct { using _: NS.Object } + +@(objc_type=ResourceStateCommandEncoder, objc_name="updateFence") +ResourceStateCommandEncoder_updateFence :: proc(self: ^ResourceStateCommandEncoder, fence: ^NS.Object) { + msgSend(nil, self, "updateFence:", fence) +} +@(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMapping_mode_indirectBuffer_indirectBufferOffset_") +ResourceStateCommandEncoder_updateTextureMapping_mode_indirectBuffer_indirectBufferOffset_ :: proc(self: ^ResourceStateCommandEncoder, texture: ^NS.Object, mode: SparseTextureMappingMode, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { + msgSend(nil, self, "updateTextureMapping:mode:indirectBuffer:indirectBufferOffset:", texture, mode, indirectBuffer, indirectBufferOffset) +} +@(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMapping_mode_region_mipLevel_slice_") +ResourceStateCommandEncoder_updateTextureMapping_mode_region_mipLevel_slice_ :: proc(self: ^ResourceStateCommandEncoder, texture: ^NS.Object, mode: SparseTextureMappingMode, region: Region, mipLevel: NS.Integer, slice: NS.Integer) { + msgSend(nil, self, "updateTextureMapping:mode:region:mipLevel:slice:", texture, mode, region, mipLevel, slice) +} +@(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMappings") +ResourceStateCommandEncoder_updateTextureMappings :: proc(self: ^ResourceStateCommandEncoder, texture: ^NS.Object, mode: SparseTextureMappingMode, regions: ^Region, mipLevels: NS.Integer, slices: NS.Integer, numRegions: ^NS.Object) { + msgSend(nil, self, "updateTextureMappings:mode:regions:mipLevels:slices:numRegions:", texture, mode, regions, mipLevels, slices, numRegions) +} +@(objc_type=ResourceStateCommandEncoder, objc_name="waitForFence") +ResourceStateCommandEncoder_waitForFence :: proc(self: ^ResourceStateCommandEncoder, fence: ^NS.Object) { + msgSend(nil, self, "waitForFence:", fence) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + SamplerState +Class Methods: +Methods: + device + label +*/ +@(objc_class="MTLSamplerState") +SamplerState :: struct { using _: NS.Object } + +@(objc_type=SamplerState, objc_name="device") +SamplerState_device :: proc(self: ^SamplerState) -> ^SamplerState { + return msgSend(^SamplerState, self, "device") +} +@(objc_type=SamplerState, objc_name="label") +SamplerState_label :: proc(self: ^SamplerState) -> ^NS.String { + return msgSend(^NS.String, self, "label") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + SharedEvent +Class Methods: +Methods: + newSharedEventHandle + notifyListener + setSignaledValue + signaledValue +*/ +@(objc_class="MTLSharedEvent") +SharedEvent :: struct { using _: NS.Object } + +@(objc_type=SharedEvent, objc_name="newSharedEventHandle") +SharedEvent_newSharedEventHandle :: proc(self: ^SharedEvent) -> ^SharedEventHandle { + return msgSend(^SharedEventHandle, self, "newSharedEventHandle") +} +@(objc_type=SharedEvent, objc_name="notifyListener") +SharedEvent_notifyListener :: proc(self: ^SharedEvent, listener: ^SharedEventListener, value: u64, block: SharedEventNotificationBlock) { + msgSend(nil, self, "notifyListener:atValue:block:", listener, value, block) +} +@(objc_type=SharedEvent, objc_name="setSignaledValue") +SharedEvent_setSignaledValue :: proc(self: ^SharedEvent, signaledValue: u64) { + msgSend(nil, self, "setSignaledValue:", signaledValue) +} +@(objc_type=SharedEvent, objc_name="signaledValue") +SharedEvent_signaledValue :: proc(self: ^SharedEvent) -> u64 { + return msgSend(u64, self, "signaledValue") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + Texture +Class Methods: +Methods: + allowGPUOptimizedContents + arrayLength + buffer + bufferBytesPerRow + bufferOffset + depth + firstMipmapInTail + getBytes + getBytes + height + iosurface + iosurfacePlane + isFramebufferOnly + isShareable + isSparse + mipmapLevelCount + newRemoteTextureViewForDevice + newSharedTextureHandle + newTextureViewWithPixelFormat + newTextureViewWithPixelFormat + newTextureViewWithPixelFormat + parentRelativeLevel + parentRelativeSlice + parentTexture + pixelFormat + remoteStorageTexture + replaceRegion + replaceRegion + rootResource + sampleCount + swizzle + tailSizeInBytes + textureType + usage + width +*/ +@(objc_class="MTLTexture") +Texture :: struct { using _: NS.Object } + +@(objc_type=Texture, objc_name="allowGPUOptimizedContents") +Texture_allowGPUOptimizedContents :: proc(self: ^Texture) -> BOOL { + return msgSend(BOOL, self, "allowGPUOptimizedContents") +} +@(objc_type=Texture, objc_name="arrayLength") +Texture_arrayLength :: proc(self: ^Texture) -> NS.Integer { + return msgSend(NS.Integer, self, "arrayLength") +} +@(objc_type=Texture, objc_name="buffer") +Texture_buffer :: proc(self: ^Texture) -> ^Texture { + return msgSend(^Texture, self, "buffer") +} +@(objc_type=Texture, objc_name="bufferBytesPerRow") +Texture_bufferBytesPerRow :: proc(self: ^Texture) -> NS.Integer { + return msgSend(NS.Integer, self, "bufferBytesPerRow") +} +@(objc_type=Texture, objc_name="bufferOffset") +Texture_bufferOffset :: proc(self: ^Texture) -> NS.Integer { + return msgSend(NS.Integer, self, "bufferOffset") +} +@(objc_type=Texture, objc_name="depth") +Texture_depth :: proc(self: ^Texture) -> NS.Integer { + return msgSend(NS.Integer, self, "depth") +} +@(objc_type=Texture, objc_name="firstMipmapInTail") +Texture_firstMipmapInTail :: proc(self: ^Texture) -> NS.Integer { + return msgSend(NS.Integer, self, "firstMipmapInTail") +} +@(objc_type=Texture, objc_name="getBytes_bytesPerRow_bytesPerImage_fromRegion_mipmapLevel_slice_") +Texture_getBytes_bytesPerRow_bytesPerImage_fromRegion_mipmapLevel_slice_ :: proc(self: ^Texture, pixelBytes: rawptr, bytesPerRow: ^NS.Object, bytesPerImage: ^NS.Object, region: Region, level: ^NS.Object, slice: ^NS.Object) { + msgSend(nil, self, "getBytes:bytesPerRow:bytesPerImage:fromRegion:mipmapLevel:slice:", pixelBytes, bytesPerRow, bytesPerImage, region, level, slice) +} +@(objc_type=Texture, objc_name="getBytes_bytesPerRow_fromRegion_mipmapLevel_") +Texture_getBytes_bytesPerRow_fromRegion_mipmapLevel_ :: proc(self: ^Texture, pixelBytes: rawptr, bytesPerRow: ^NS.Object, region: Region, level: ^NS.Object) { + msgSend(nil, self, "getBytes:bytesPerRow:fromRegion:mipmapLevel:", pixelBytes, bytesPerRow, region, level) +} +@(objc_type=Texture, objc_name="height") +Texture_height :: proc(self: ^Texture) -> NS.Integer { + return msgSend(NS.Integer, self, "height") +} +@(objc_type=Texture, objc_name="iosurface") +Texture_iosurface :: proc(self: ^Texture) -> IOSurfaceRef { + return msgSend(IOSurfaceRef, self, "iosurface") +} +@(objc_type=Texture, objc_name="iosurfacePlane") +Texture_iosurfacePlane :: proc(self: ^Texture) -> NS.Integer { + return msgSend(NS.Integer, self, "iosurfacePlane") +} +@(objc_type=Texture, objc_name="isFramebufferOnly") +Texture_isFramebufferOnly :: proc(self: ^Texture) -> BOOL { + return msgSend(BOOL, self, "isFramebufferOnly") +} +@(objc_type=Texture, objc_name="isShareable") +Texture_isShareable :: proc(self: ^Texture) -> BOOL { + return msgSend(BOOL, self, "isShareable") +} +@(objc_type=Texture, objc_name="isSparse") +Texture_isSparse :: proc(self: ^Texture) -> BOOL { + return msgSend(BOOL, self, "isSparse") +} +@(objc_type=Texture, objc_name="mipmapLevelCount") +Texture_mipmapLevelCount :: proc(self: ^Texture) -> NS.Integer { + return msgSend(NS.Integer, self, "mipmapLevelCount") +} +@(objc_type=Texture, objc_name="newRemoteTextureViewForDevice") +Texture_newRemoteTextureViewForDevice :: proc(self: ^Texture, device: ^NS.Object) -> ^Texture { + return msgSend(^Texture, self, "newRemoteTextureViewForDevice:", device) +} +@(objc_type=Texture, objc_name="newSharedTextureHandle") +Texture_newSharedTextureHandle :: proc(self: ^Texture) -> ^SharedTextureHandle { + return msgSend(^SharedTextureHandle, self, "newSharedTextureHandle") +} +@(objc_type=Texture, objc_name="newTextureViewWithPixelFormat") +Texture_newTextureViewWithPixelFormat :: proc(self: ^Texture, pixelFormat: PixelFormat) -> ^Texture { + return msgSend(^Texture, self, "newTextureViewWithPixelFormat:", pixelFormat) +} +@(objc_type=Texture, objc_name="newTextureViewWithPixelFormat_textureType_levels_slices_") +Texture_newTextureViewWithPixelFormat_textureType_levels_slices_ :: proc(self: ^Texture, pixelFormat: PixelFormat, textureType: TextureType, levelRange: NS.Range, sliceRange: NS.Range) -> ^Texture { + return msgSend(^Texture, self, "newTextureViewWithPixelFormat:textureType:levels:slices:", pixelFormat, textureType, levelRange, sliceRange) +} +@(objc_type=Texture, objc_name="newTextureViewWithPixelFormat_textureType_levels_slices_swizzle_") +Texture_newTextureViewWithPixelFormat_textureType_levels_slices_swizzle_ :: proc(self: ^Texture, pixelFormat: PixelFormat, textureType: TextureType, levelRange: NS.Range, sliceRange: NS.Range, swizzle: TextureSwizzleChannels) -> ^Texture { + return msgSend(^Texture, self, "newTextureViewWithPixelFormat:textureType:levels:slices:swizzle:", pixelFormat, textureType, levelRange, sliceRange, swizzle) +} +@(objc_type=Texture, objc_name="parentRelativeLevel") +Texture_parentRelativeLevel :: proc(self: ^Texture) -> NS.Integer { + return msgSend(NS.Integer, self, "parentRelativeLevel") +} +@(objc_type=Texture, objc_name="parentRelativeSlice") +Texture_parentRelativeSlice :: proc(self: ^Texture) -> NS.Integer { + return msgSend(NS.Integer, self, "parentRelativeSlice") +} +@(objc_type=Texture, objc_name="parentTexture") +Texture_parentTexture :: proc(self: ^Texture) -> ^Texture { + return msgSend(^Texture, self, "parentTexture") +} +@(objc_type=Texture, objc_name="pixelFormat") +Texture_pixelFormat :: proc(self: ^Texture) -> PixelFormat { + return msgSend(PixelFormat, self, "pixelFormat") +} +@(objc_type=Texture, objc_name="remoteStorageTexture") +Texture_remoteStorageTexture :: proc(self: ^Texture) -> ^Texture { + return msgSend(^Texture, self, "remoteStorageTexture") +} +@(objc_type=Texture, objc_name="replaceRegion_mipmapLevel_slice_withBytes_bytesPerRow_bytesPerImage_") +Texture_replaceRegion_mipmapLevel_slice_withBytes_bytesPerRow_bytesPerImage_ :: proc(self: ^Texture, region: Region, level: ^NS.Object, slice: ^NS.Object, pixelBytes: rawptr, bytesPerRow: ^NS.Object, bytesPerImage: ^NS.Object) { + msgSend(nil, self, "replaceRegion:mipmapLevel:slice:withBytes:bytesPerRow:bytesPerImage:", region, level, slice, pixelBytes, bytesPerRow, bytesPerImage) +} +@(objc_type=Texture, objc_name="replaceRegion_mipmapLevel_withBytes_bytesPerRow_") +Texture_replaceRegion_mipmapLevel_withBytes_bytesPerRow_ :: proc(self: ^Texture, region: Region, level: ^NS.Object, pixelBytes: rawptr, bytesPerRow: ^NS.Object) { + msgSend(nil, self, "replaceRegion:mipmapLevel:withBytes:bytesPerRow:", region, level, pixelBytes, bytesPerRow) +} +@(objc_type=Texture, objc_name="rootResource") +Texture_rootResource :: proc(self: ^Texture) -> ^Texture { + return msgSend(^Texture, self, "rootResource") +} +@(objc_type=Texture, objc_name="sampleCount") +Texture_sampleCount :: proc(self: ^Texture) -> NS.Integer { + return msgSend(NS.Integer, self, "sampleCount") +} +@(objc_type=Texture, objc_name="swizzle") +Texture_swizzle :: proc(self: ^Texture) -> TextureSwizzleChannels { + return msgSend(TextureSwizzleChannels, self, "swizzle") +} +@(objc_type=Texture, objc_name="tailSizeInBytes") +Texture_tailSizeInBytes :: proc(self: ^Texture) -> NS.Integer { + return msgSend(NS.Integer, self, "tailSizeInBytes") +} +@(objc_type=Texture, objc_name="textureType") +Texture_textureType :: proc(self: ^Texture) -> TextureType { + return msgSend(TextureType, self, "textureType") +} +@(objc_type=Texture, objc_name="usage") +Texture_usage :: proc(self: ^Texture) -> TextureUsage { + return msgSend(TextureUsage, self, "usage") +} +@(objc_type=Texture, objc_name="width") +Texture_width :: proc(self: ^Texture) -> NS.Integer { + return msgSend(NS.Integer, self, "width") +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + VisibleFunctionTable +Class Methods: +Methods: + setFunction + setFunctions +*/ +@(objc_class="MTLVisibleFunctionTable") +VisibleFunctionTable :: struct { using _: NS.Object } + +@(objc_type=VisibleFunctionTable, objc_name="setFunction") +VisibleFunctionTable_setFunction :: proc(self: ^VisibleFunctionTable, function: ^NS.Object, index: ^NS.Object) { + msgSend(nil, self, "setFunction:atIndex:", function, index) +} +@(objc_type=VisibleFunctionTable, objc_name="setFunctions") +VisibleFunctionTable_setFunctions :: proc(self: ^VisibleFunctionTable, functions: ^^NS.Object, range: NS.Range) { + msgSend(nil, self, "setFunctions:withRange:", functions, range) +} diff --git a/vendor/Metal/MetalEnums.odin b/vendor/Metal/MetalEnums.odin new file mode 100644 index 000000000..a0bd7b970 --- /dev/null +++ b/vendor/Metal/MetalEnums.odin @@ -0,0 +1,961 @@ +package objc_Metal + +import NS "core:sys/darwin/Foundation" + +AccelerationStructureUsage :: distinct bit_set[AccelerationStructureUsageFlag; NS.UInteger] +AccelerationStructureUsageFlag :: enum NS.UInteger { + Refit = 0, + PreferFastBuild = 1, + ExtendedLimits = 2, +} + +AccelerationStructureInstanceOptions :: distinct bit_set[AccelerationStructureInstanceOption; u32] +AccelerationStructureInstanceOption :: enum u32 { + DisableTriangleCulling = 0, + TriangleFrontFacingWindingCounterClockwise = 1, + Opaque = 2, + NonOpaque = 3, +} + + +DataType :: enum NS.UInteger { + None = 0, + Struct = 1, + Array = 2, + Float = 3, + Float2 = 4, + Float3 = 5, + Float4 = 6, + Float2x2 = 7, + Float2x3 = 8, + Float2x4 = 9, + Float3x2 = 10, + Float3x3 = 11, + Float3x4 = 12, + Float4x2 = 13, + Float4x3 = 14, + Float4x4 = 15, + Half = 16, + Half2 = 17, + Half3 = 18, + Half4 = 19, + Half2x2 = 20, + Half2x3 = 21, + Half2x4 = 22, + Half3x2 = 23, + Half3x3 = 24, + Half3x4 = 25, + Half4x2 = 26, + Half4x3 = 27, + Half4x4 = 28, + Int = 29, + Int2 = 30, + Int3 = 31, + Int4 = 32, + UInt = 33, + UInt2 = 34, + UInt3 = 35, + UInt4 = 36, + Short = 37, + Short2 = 38, + Short3 = 39, + Short4 = 40, + UShort = 41, + UShort2 = 42, + UShort3 = 43, + UShort4 = 44, + Char = 45, + Char2 = 46, + Char3 = 47, + Char4 = 48, + UChar = 49, + UChar2 = 50, + UChar3 = 51, + UChar4 = 52, + Bool = 53, + Bool2 = 54, + Bool3 = 55, + Bool4 = 56, + Texture = 58, + Sampler = 59, + Pointer = 60, + R8Unorm = 62, + R8Snorm = 63, + R16Unorm = 64, + R16Snorm = 65, + RG8Unorm = 66, + RG8Snorm = 67, + RG16Unorm = 68, + RG16Snorm = 69, + RGBA8Unorm = 70, + RGBA8Unorm_sRGB = 71, + RGBA8Snorm = 72, + RGBA16Unorm = 73, + RGBA16Snorm = 74, + RGB10A2Unorm = 75, + RG11B10Float = 76, + RGB9E5Float = 77, + RenderPipeline = 78, + ComputePipeline = 79, + IndirectCommandBuffer = 80, + Long = 81, + Long2 = 82, + Long3 = 83, + Long4 = 84, + ULong = 85, + ULong2 = 86, + ULong3 = 87, + ULong4 = 88, + VisibleFunctionTable = 115, + IntersectionFunctionTable = 116, + PrimitiveAccelerationStructure = 117, + InstanceAccelerationStructure = 118, +} + +ArgumentType :: enum NS.UInteger { + Buffer = 0, + ThreadgroupMemory = 1, + Texture = 2, + Sampler = 3, + ImageblockData = 16, + Imageblock = 17, + VisibleFunctionTable = 24, + PrimitiveAccelerationStructure = 25, + InstanceAccelerationStructure = 26, + IntersectionFunctionTable = 27, +} + +ArgumentAccess :: enum NS.UInteger { + ReadOnly = 0, + ReadWrite = 1, + WriteOnly = 2, +} + + +BinaryArchiveError :: enum NS.UInteger { + None = 0, + InvalidFile = 1, + UnexpectedElement = 2, + CompilationFailure = 3, +} + +BlitOptionFlag :: enum NS.UInteger { + DepthFromDepthStencil = 0, + StencilFromDepthStencil = 1, + RowLinearPVRTC = 2, +} +BlitOption :: distinct bit_set[BlitOptionFlag; NS.UInteger] + +CaptureError :: enum NS.Integer { + NotSupported = 1, + AlreadyCapturing = 2, + InvalidDescriptor = 3, +} + +CaptureDestination :: enum NS.Integer { + DeveloperTools = 1, + GPUTraceDocument = 2, +} + + +CommandBufferStatus :: enum NS.UInteger { + NotEnqueued = 0, + Enqueued = 1, + Committed = 2, + Scheduled = 3, + Completed = 4, + Error = 5, +} + +CommandBufferError :: enum NS.UInteger { + None = 0, + Timeout = 2, + PageFault = 3, + AccessRevoked = 4, + Blacklisted = 4, + NotPermitted = 7, + OutOfMemory = 8, + InvalidResource = 9, + Memoryless = 10, + DeviceRemoved = 11, + StackOverflow = 12, +} + +CommandBufferErrorOptionFlag :: enum NS.UInteger { + EncoderExecutionStatus = 0, +} +CommandBufferErrorOption :: distinct bit_set[CommandBufferErrorOptionFlag; NS.UInteger] + +CommandEncoderErrorState :: enum NS.Integer { + Unknown = 0, + Completed = 1, + Affected = 2, + Pending = 3, + Faulted = 4, +} + +CommandBufferHandler :: distinct rawptr + +DispatchType :: enum NS.UInteger { + Serial = 0, + Concurrent = 1, +} + +ResourceUsageFlag :: enum NS.UInteger { + Read = 0, + Write = 1, + Sample = 2, +} +ResourceUsage :: distinct bit_set[ResourceUsageFlag; NS.UInteger] + + +BarrierScopeFlag :: enum NS.UInteger { + Buffers = 0, + Textures = 1, + RenderTargets = 2, +} +BarrierScope :: distinct bit_set[BarrierScopeFlag; NS.UInteger] + + + +CounterSampleBufferError :: enum NS.Integer { + OutOfMemory = 0, + Invalid = 1, +} + +CompareFunction :: enum NS.UInteger { + Never = 0, + Less = 1, + Equal = 2, + LessEqual = 3, + Greater = 4, + NotEqual = 5, + GreaterEqual = 6, + Always = 7, +} + +StencilOperation :: enum NS.UInteger { + Keep = 0, + Zero = 1, + Replace = 2, + IncrementClamp = 3, + DecrementClamp = 4, + Invert = 5, + IncrementWrap = 6, + DecrementWrap = 7, +} + +FeatureSet :: enum NS.UInteger { + iOS_GPUFamily1_v1 = 0, + iOS_GPUFamily2_v1 = 1, + iOS_GPUFamily1_v2 = 2, + iOS_GPUFamily2_v2 = 3, + iOS_GPUFamily3_v1 = 4, + iOS_GPUFamily1_v3 = 5, + iOS_GPUFamily2_v3 = 6, + iOS_GPUFamily3_v2 = 7, + iOS_GPUFamily1_v4 = 8, + iOS_GPUFamily2_v4 = 9, + iOS_GPUFamily3_v3 = 10, + iOS_GPUFamily4_v1 = 11, + iOS_GPUFamily1_v5 = 12, + iOS_GPUFamily2_v5 = 13, + iOS_GPUFamily3_v4 = 14, + iOS_GPUFamily4_v2 = 15, + iOS_GPUFamily5_v1 = 16, + macOS_GPUFamily1_v1 = 10000, + OSX_GPUFamily1_v1 = 10000, + macOS_GPUFamily1_v2 = 10001, + OSX_GPUFamily1_v2 = 10001, + OSX_ReadWriteTextureTier2 = 10002, + macOS_ReadWriteTextureTier2 = 10002, + macOS_GPUFamily1_v3 = 10003, + macOS_GPUFamily1_v4 = 10004, + macOS_GPUFamily2_v1 = 10005, + watchOS_GPUFamily1_v1 = 20000, + WatchOS_GPUFamily1_v1 = 20000, + watchOS_GPUFamily2_v1 = 20001, + WatchOS_GPUFamily2_v1 = 20001, + tvOS_GPUFamily1_v1 = 30000, + TVOS_GPUFamily1_v1 = 30000, + tvOS_GPUFamily1_v2 = 30001, + tvOS_GPUFamily1_v3 = 30002, + tvOS_GPUFamily2_v1 = 30003, + tvOS_GPUFamily1_v4 = 30004, + tvOS_GPUFamily2_v2 = 30005, +} + +GPUFamily :: enum NS.Integer { + Apple1 = 1001, + Apple2 = 1002, + Apple3 = 1003, + Apple4 = 1004, + Apple5 = 1005, + Apple6 = 1006, + Apple7 = 1007, + Apple8 = 1008, + Mac1 = 2001, + Mac2 = 2002, + Common1 = 3001, + Common2 = 3002, + Common3 = 3003, + MacCatalyst1 = 4001, + MacCatalyst2 = 4002, +} + +DeviceLocation :: enum NS.UInteger { + BuiltIn = 0, + Slot = 1, + External = 2, + Unspecified = NS.UIntegerMax, +} + +PipelineOptionFlag :: enum NS.UInteger { + ArgumentInfo = 0, + BufferTypeInfo = 1, + FailOnBinaryArchiveMiss = 2, +} +PipelineOption :: distinct bit_set[PipelineOptionFlag; NS.UInteger] + +ReadWriteTextureTier :: enum NS.UInteger { + TierNone = 0, + Tier1 = 1, + Tier2 = 2, +} + +ArgumentBuffersTier :: enum NS.UInteger { + Tier1 = 0, + Tier2 = 1, +} + +SparseTextureRegionAlignmentMode :: enum NS.UInteger { + Outward = 0, + Inward = 1, +} + +CounterSamplingPoint :: enum NS.UInteger { + AtStageBoundary = 0, + AtDrawBoundary = 1, + AtDispatchBoundary = 2, + AtTileDispatchBoundary = 3, + AtBlitBoundary = 4, +} + +DynamicLibraryError :: enum NS.UInteger { + None = 0, + InvalidFile = 1, + CompilationFailure = 2, + UnresolvedInstallName = 3, + DependencyLoadFailure = 4, + Unsupported = 5, +} + +FunctionOption :: enum NS.UInteger { + CompileToBinary = 0, +} +FunctionOptions :: distinct bit_set[FunctionOption; NS.UInteger] + + +FunctionLogType :: enum NS.UInteger { + Validation = 0, +} + +HeapType :: enum NS.Integer { + Automatic = 0, + Placement = 1, + Sparse = 2, +} + +IndirectCommandTypeFlag :: enum NS.UInteger { + Draw = 0, + DrawIndexed = 1, + DrawPatches = 2, + DrawIndexedPatches = 3, + ConcurrentDispatch = 5, + ConcurrentDispatchThreads = 6, +} +IndirectCommandType :: distinct bit_set[IndirectCommandTypeFlag; NS.UInteger] + +IntersectionFunctionSignatureFlag :: enum NS.UInteger { + Instancing = 0, + TriangleData = 1, + WorldSpaceData = 2, + InstanceMotion = 3, + PrimitiveMotion = 4, + ExtendedLimits = 5, +} +IntersectionFunctionSignature :: distinct bit_set[IntersectionFunctionSignatureFlag; NS.UInteger] + +PatchType :: enum NS.UInteger { + None = 0, + Triangle = 1, + Quad = 2, +} + +FunctionType :: enum NS.UInteger { + Vertex = 1, + Fragment = 2, + Kernel = 3, + Visible = 5, + Intersection = 6, +} + + +LanguageVersion :: enum NS.UInteger { + Version1_0 = 65536, + Version1_1 = 65537, + Version1_2 = 65538, + Version2_0 = 131072, + Version2_1 = 131073, + Version2_2 = 131074, + Version2_3 = 131075, + Version2_4 = 131076, +} + +LibraryType :: enum NS.Integer { + Executable = 0, + Dynamic = 1, +} + +LibraryError :: enum NS.UInteger { + Unsupported = 1, + CompileFailure = 3, + CompileWarning = 4, + FunctionNotFound = 5, + FileNotFound = 6, +} + +Mutability :: enum NS.UInteger { + Default = 0, + Mutable = 1, + Immutable = 2, +} + +PixelFormat :: enum NS.UInteger { + Invalid = 0, + A8Unorm = 1, + R8Unorm = 10, + R8Unorm_sRGB = 11, + R8Snorm = 12, + R8Uint = 13, + R8Sint = 14, + R16Unorm = 20, + R16Snorm = 22, + R16Uint = 23, + R16Sint = 24, + R16Float = 25, + RG8Unorm = 30, + RG8Unorm_sRGB = 31, + RG8Snorm = 32, + RG8Uint = 33, + RG8Sint = 34, + B5G6R5Unorm = 40, + A1BGR5Unorm = 41, + ABGR4Unorm = 42, + BGR5A1Unorm = 43, + R32Uint = 53, + R32Sint = 54, + R32Float = 55, + RG16Unorm = 60, + RG16Snorm = 62, + RG16Uint = 63, + RG16Sint = 64, + RG16Float = 65, + RGBA8Unorm = 70, + RGBA8Unorm_sRGB = 71, + RGBA8Snorm = 72, + RGBA8Uint = 73, + RGBA8Sint = 74, + BGRA8Unorm = 80, + BGRA8Unorm_sRGB = 81, + RGB10A2Unorm = 90, + RGB10A2Uint = 91, + RG11B10Float = 92, + RGB9E5Float = 93, + BGR10A2Unorm = 94, + RG32Uint = 103, + RG32Sint = 104, + RG32Float = 105, + RGBA16Unorm = 110, + RGBA16Snorm = 112, + RGBA16Uint = 113, + RGBA16Sint = 114, + RGBA16Float = 115, + RGBA32Uint = 123, + RGBA32Sint = 124, + RGBA32Float = 125, + BC1_RGBA = 130, + BC1_RGBA_sRGB = 131, + BC2_RGBA = 132, + BC2_RGBA_sRGB = 133, + BC3_RGBA = 134, + BC3_RGBA_sRGB = 135, + BC4_RUnorm = 140, + BC4_RSnorm = 141, + BC5_RGUnorm = 142, + BC5_RGSnorm = 143, + BC6H_RGBFloat = 150, + BC6H_RGBUfloat = 151, + BC7_RGBAUnorm = 152, + BC7_RGBAUnorm_sRGB = 153, + PVRTC_RGB_2BPP = 160, + PVRTC_RGB_2BPP_sRGB = 161, + PVRTC_RGB_4BPP = 162, + PVRTC_RGB_4BPP_sRGB = 163, + PVRTC_RGBA_2BPP = 164, + PVRTC_RGBA_2BPP_sRGB = 165, + PVRTC_RGBA_4BPP = 166, + PVRTC_RGBA_4BPP_sRGB = 167, + EAC_R11Unorm = 170, + EAC_R11Snorm = 172, + EAC_RG11Unorm = 174, + EAC_RG11Snorm = 176, + EAC_RGBA8 = 178, + EAC_RGBA8_sRGB = 179, + ETC2_RGB8 = 180, + ETC2_RGB8_sRGB = 181, + ETC2_RGB8A1 = 182, + ETC2_RGB8A1_sRGB = 183, + ASTC_4x4_sRGB = 186, + ASTC_5x4_sRGB = 187, + ASTC_5x5_sRGB = 188, + ASTC_6x5_sRGB = 189, + ASTC_6x6_sRGB = 190, + ASTC_8x5_sRGB = 192, + ASTC_8x6_sRGB = 193, + ASTC_8x8_sRGB = 194, + ASTC_10x5_sRGB = 195, + ASTC_10x6_sRGB = 196, + ASTC_10x8_sRGB = 197, + ASTC_10x10_sRGB = 198, + ASTC_12x10_sRGB = 199, + ASTC_12x12_sRGB = 200, + ASTC_4x4_LDR = 204, + ASTC_5x4_LDR = 205, + ASTC_5x5_LDR = 206, + ASTC_6x5_LDR = 207, + ASTC_6x6_LDR = 208, + ASTC_8x5_LDR = 210, + ASTC_8x6_LDR = 211, + ASTC_8x8_LDR = 212, + ASTC_10x5_LDR = 213, + ASTC_10x6_LDR = 214, + ASTC_10x8_LDR = 215, + ASTC_10x10_LDR = 216, + ASTC_12x10_LDR = 217, + ASTC_12x12_LDR = 218, + ASTC_4x4_HDR = 222, + ASTC_5x4_HDR = 223, + ASTC_5x5_HDR = 224, + ASTC_6x5_HDR = 225, + ASTC_6x6_HDR = 226, + ASTC_8x5_HDR = 228, + ASTC_8x6_HDR = 229, + ASTC_8x8_HDR = 230, + ASTC_10x5_HDR = 231, + ASTC_10x6_HDR = 232, + ASTC_10x8_HDR = 233, + ASTC_10x10_HDR = 234, + ASTC_12x10_HDR = 235, + ASTC_12x12_HDR = 236, + GBGR422 = 240, + BGRG422 = 241, + Depth16Unorm = 250, + Depth32Float = 252, + Stencil8 = 253, + Depth24Unorm_Stencil8 = 255, + Depth32Float_Stencil8 = 260, + X32_Stencil8 = 261, + X24_Stencil8 = 262, + BGRA10_XR = 552, + BGRA10_XR_sRGB = 553, + BGR10_XR = 554, + BGR10_XR_sRGB = 555, +} + + +PrimitiveType :: enum NS.UInteger { + Point = 0, + Line = 1, + LineStrip = 2, + Triangle = 3, + TriangleStrip = 4, +} + +VisibilityResultMode :: enum NS.UInteger { + Disabled = 0, + Boolean = 1, + Counting = 2, +} + +CullMode :: enum NS.UInteger { + None = 0, + Front = 1, + Back = 2, +} + +Winding :: enum NS.UInteger { + Clockwise = 0, + CounterClockwise = 1, +} + +DepthClipMode :: enum NS.UInteger { + Clip = 0, + Clamp = 1, +} + +TriangleFillMode :: enum NS.UInteger { + Fill = 0, + Lines = 1, +} + +RenderStage :: enum NS.UInteger { + Vertex = 0, + Fragment = 1, + Tile = 2, +} +RenderStages :: distinct bit_set[RenderStage; NS.UInteger] + + +LoadAction :: enum NS.UInteger { + DontCare = 0, + Load = 1, + Clear = 2, +} + +StoreAction :: enum NS.UInteger { + DontCare = 0, + Store = 1, + MultisampleResolve = 2, + StoreAndMultisampleResolve = 3, + Unknown = 4, + CustomSampleDepthStore = 5, +} + +StoreActionOption :: enum NS.UInteger { + CustomSamplePositions = 1, +} +StoreActionOptions :: distinct bit_set[StoreActionOption; NS.UInteger] + +MultisampleDepthResolveFilter :: enum NS.UInteger { + Sample0 = 0, + Min = 1, + Max = 2, +} + +MultisampleStencilResolveFilter :: enum NS.UInteger { + Sample0 = 0, + DepthResolvedSample = 1, +} + +BlendFactor :: enum NS.UInteger { + Zero = 0, + One = 1, + SourceColor = 2, + OneMinusSourceColor = 3, + SourceAlpha = 4, + OneMinusSourceAlpha = 5, + DestinationColor = 6, + OneMinusDestinationColor = 7, + DestinationAlpha = 8, + OneMinusDestinationAlpha = 9, + SourceAlphaSaturated = 10, + BlendColor = 11, + OneMinusBlendColor = 12, + BlendAlpha = 13, + OneMinusBlendAlpha = 14, + Source1Color = 15, + OneMinusSource1Color = 16, + Source1Alpha = 17, + OneMinusSource1Alpha = 18, +} + +BlendOperation :: enum NS.UInteger { + Add = 0, + Subtract = 1, + ReverseSubtract = 2, + Min = 3, + Max = 4, +} + +ColorWriteMaskFlag :: enum NS.UInteger { + Alpha = 0, + Blue = 1, + Green = 2, + Red = 3, +} +ColorWriteMask :: distinct bit_set[ColorWriteMaskFlag; NS.UInteger] +ColorWriteMaskAll :: ColorWriteMask{.Alpha, .Blue, .Green, .Red} + +PrimitiveTopologyClass :: enum NS.UInteger { + Unspecified = 0, + Point = 1, + Line = 2, + Triangle = 3, +} + +TessellationPartitionMode :: enum NS.UInteger { + Pow2 = 0, + Integer = 1, + FractionalOdd = 2, + FractionalEven = 3, +} + +TessellationFactorStepFunction :: enum NS.UInteger { + Constant = 0, + PerPatch = 1, + PerInstance = 2, + PerPatchAndPerInstance = 3, +} + +TessellationFactorFormat :: enum NS.UInteger { + Half = 0, +} + +TessellationControlPointIndexType :: enum NS.UInteger { + None = 0, + UInt16 = 1, + UInt32 = 2, +} + +PurgeableState :: enum NS.UInteger { + KeepCurrent = 1, + NonVolatile = 2, + Volatile = 3, + Empty = 4, +} + +CPUCacheMode :: enum NS.UInteger { + DefaultCache = 0, + WriteCombined = 1, +} + +StorageMode :: enum NS.UInteger { + Shared = 0, + Managed = 1, + Private = 2, + Memoryless = 3, +} + +HazardTrackingMode :: enum NS.UInteger { + Default = 0, + Untracked = 1, + Tracked = 2, +} + +ResourceOption :: enum NS.UInteger { + CPUCacheModeWriteCombined = 0, + StorageModeManaged = 4, + StorageModePrivate = 5, + HazardTrackingModeUntracked = 8, + HazardTrackingModeTracked = 9, +} +ResourceOptions :: distinct bit_set[ResourceOption; NS.UInteger] + +ResourceStorageModeShared :: ResourceOptions{} +ResourceHazardTrackingModeDefault :: ResourceOptions{} +ResourceCPUCacheModeDefaultCache :: ResourceOptions{} +ResourceOptionCPUCacheModeDefault :: ResourceOptions{} +ResourceStorageModeMemoryless :: ResourceOptions{.StorageModeManaged, .StorageModePrivate} + +SparseTextureMappingMode :: enum NS.UInteger { + Map = 0, + Unmap = 1, +} + +SamplerMinMagFilter :: enum NS.UInteger { + Nearest = 0, + Linear = 1, +} + +SamplerMipFilter :: enum NS.UInteger { + NotMipmapped = 0, + Nearest = 1, + Linear = 2, +} + +SamplerAddressMode :: enum NS.UInteger { + ClampToEdge = 0, + MirrorClampToEdge = 1, + Repeat = 2, + MirrorRepeat = 3, + ClampToZero = 4, + ClampToBorderColor = 5, +} + +SamplerBorderColor :: enum NS.UInteger { + TransparentBlack = 0, + OpaqueBlack = 1, + OpaqueWhite = 2, +} + + +AttributeFormat :: enum NS.UInteger { + Invalid = 0, + UChar2 = 1, + UChar3 = 2, + UChar4 = 3, + Char2 = 4, + Char3 = 5, + Char4 = 6, + UChar2Normalized = 7, + UChar3Normalized = 8, + UChar4Normalized = 9, + Char2Normalized = 10, + Char3Normalized = 11, + Char4Normalized = 12, + UShort2 = 13, + UShort3 = 14, + UShort4 = 15, + Short2 = 16, + Short3 = 17, + Short4 = 18, + UShort2Normalized = 19, + UShort3Normalized = 20, + UShort4Normalized = 21, + Short2Normalized = 22, + Short3Normalized = 23, + Short4Normalized = 24, + Half2 = 25, + Half3 = 26, + Half4 = 27, + Float = 28, + Float2 = 29, + Float3 = 30, + Float4 = 31, + Int = 32, + Int2 = 33, + Int3 = 34, + Int4 = 35, + UInt = 36, + UInt2 = 37, + UInt3 = 38, + UInt4 = 39, + Int1010102Normalized = 40, + UInt1010102Normalized = 41, + UChar4Normalized_BGRA = 42, + UChar = 45, + Char = 46, + UCharNormalized = 47, + CharNormalized = 48, + UShort = 49, + Short = 50, + UShortNormalized = 51, + ShortNormalized = 52, + Half = 53, +} + +IndexType :: enum NS.UInteger { + UInt16 = 0, + UInt32 = 1, +} + +StepFunction :: enum NS.UInteger { + Constant = 0, + PerVertex = 1, + PerInstance = 2, + PerPatch = 3, + PerPatchControlPoint = 4, + ThreadPositionInGridX = 5, + ThreadPositionInGridY = 6, + ThreadPositionInGridXIndexed = 7, + ThreadPositionInGridYIndexed = 8, +} + +TextureType :: enum NS.UInteger { + Type1D = 0, + Type1DArray = 1, + Type2D = 2, + Type2DArray = 3, + Type2DMultisample = 4, + TypeCube = 5, + TypeCubeArray = 6, + Type3D = 7, + Type2DMultisampleArray = 8, + TypeTextureBuffer = 9, +} + +TextureSwizzle :: enum u8 { + Zero = 0, + One = 1, + Red = 2, + Green = 3, + Blue = 4, + Alpha = 5, +} + +TextureUsageFlag :: enum NS.UInteger { + ShaderRead = 0, + ShaderWrite = 1, + RenderTarget = 2, + PixelFormatView = 4, +} +TextureUsage :: distinct bit_set[TextureUsageFlag; NS.UInteger] + +TextureCompressionType :: enum NS.Integer { + Lossless = 0, + Lossy = 1, +} + +VertexFormat :: enum NS.UInteger { + Invalid = 0, + UChar2 = 1, + UChar3 = 2, + UChar4 = 3, + Char2 = 4, + Char3 = 5, + Char4 = 6, + UChar2Normalized = 7, + UChar3Normalized = 8, + UChar4Normalized = 9, + Char2Normalized = 10, + Char3Normalized = 11, + Char4Normalized = 12, + UShort2 = 13, + UShort3 = 14, + UShort4 = 15, + Short2 = 16, + Short3 = 17, + Short4 = 18, + UShort2Normalized = 19, + UShort3Normalized = 20, + UShort4Normalized = 21, + Short2Normalized = 22, + Short3Normalized = 23, + Short4Normalized = 24, + Half2 = 25, + Half3 = 26, + Half4 = 27, + Float = 28, + Float2 = 29, + Float3 = 30, + Float4 = 31, + Int = 32, + Int2 = 33, + Int3 = 34, + Int4 = 35, + UInt = 36, + UInt2 = 37, + UInt3 = 38, + UInt4 = 39, + Int1010102Normalized = 40, + UInt1010102Normalized = 41, + UChar4Normalized_BGRA = 42, + UChar = 45, + Char = 46, + UCharNormalized = 47, + CharNormalized = 48, + UShort = 49, + Short = 50, + UShortNormalized = 51, + ShortNormalized = 52, + Half = 53, +} + +VertexStepFunction :: enum NS.UInteger { + Constant = 0, + PerVertex = 1, + PerInstance = 2, + PerPatch = 3, + PerPatchControlPoint = 4, +} diff --git a/vendor/Metal/MetalErrors.odin b/vendor/Metal/MetalErrors.odin new file mode 100644 index 000000000..5909b35e4 --- /dev/null +++ b/vendor/Metal/MetalErrors.odin @@ -0,0 +1,39 @@ +package objc_Metal + +import NS "core:sys/darwin/Foundation" + +foreign import "system:Metal.framework" + +CommonCounter :: ^NS.String +CommonCounterSet :: ^NS.String +DeviceNotificationName :: ^NS.String + +foreign Metal { + @(linkage="weak") CommonCounterTimestamp: CommonCounter + @(linkage="weak") CommonCounterTessellationInputPatches: CommonCounter + @(linkage="weak") CommonCounterVertexInvocations: CommonCounter + @(linkage="weak") CommonCounterPostTessellationVertexInvocations: CommonCounter + @(linkage="weak") CommonCounterClipperInvocations: CommonCounter + @(linkage="weak") CommonCounterClipperPrimitivesOut: CommonCounter + @(linkage="weak") CommonCounterFragmentInvocations: CommonCounter + @(linkage="weak") CommonCounterFragmentsPassed: CommonCounter + @(linkage="weak") CommonCounterComputeKernelInvocations: CommonCounter + @(linkage="weak") CommonCounterTotalCycles: CommonCounter + @(linkage="weak") CommonCounterVertexCycles: CommonCounter + @(linkage="weak") CommonCounterTessellationCycles: CommonCounter + @(linkage="weak") CommonCounterPostTessellationVertexCycles: CommonCounter + @(linkage="weak") CommonCounterFragmentCycles: CommonCounter + @(linkage="weak") CommonCounterRenderTargetWriteCycles: CommonCounter +} + +foreign Metal { + @(linkage="weak") CommonCounterSetTimestamp: CommonCounterSet + @(linkage="weak") CommonCounterSetStageUtilization: CommonCounterSet + @(linkage="weak") CommonCounterSetStatistic: CommonCounterSet +} + +foreign Metal { + @(linkage="weak") DeviceWasAddedNotification: DeviceNotificationName + @(linkage="weak") DeviceRemovalRequestedNotification: DeviceNotificationName + @(linkage="weak") DeviceWasRemovedNotification: DeviceNotificationName +} \ No newline at end of file diff --git a/vendor/Metal/MetalTypes.odin b/vendor/Metal/MetalTypes.odin new file mode 100644 index 000000000..c8c02e5f2 --- /dev/null +++ b/vendor/Metal/MetalTypes.odin @@ -0,0 +1,198 @@ +package objc_Metal + +import NS "core:sys/darwin/Foundation" +import "core:intrinsics" + +BOOL :: NS.BOOL + +CFTimeInterval :: NS.TimeInterval + +IOSurfaceRef :: distinct rawptr + +@(private) +msgSend :: intrinsics.objc_send + +AccelerationStructureInstanceDescriptor :: struct { + transformationMatrix: PackedFloat4x3, + options: AccelerationStructureInstanceOptions, + mask: u32, + intersectionFunctionTableOffset: u32, + accelerationStructureIndex: u32, +} + +AccelerationStructureSizes :: struct { + accelerationStructureSize: NS.Integer, + buildScratchBufferSize: NS.Integer, + refitScratchBufferSize: NS.Integer, +} + +AxisAlignedBoundingBox :: struct { + min: PackedFloat3, + max: PackedFloat3, +} + +ClearColor :: struct { + red: f64, + green: f64, + blue: f64, + alpha: f64, +} + +Coordinate2D :: struct { + x: f32, + y: f32, +} + +CounterResultStageUtilization :: struct { + totalCycles: u64, + vertexCycles: u64, + tessellationCycles: u64, + postTessellationVertexCycles: u64, + fragmentCycles: u64, + renderTargetCycles: u64, +} + +CounterResultStatistic :: struct { + tessellationInputPatches: u64, + vertexInvocations: u64, + postTessellationVertexInvocations: u64, + clipperInvocations: u64, + clipperPrimitivesOut: u64, + fragmentInvocations: u64, + fragmentsPassed: u64, + computeKernelInvocations: u64, +} + +CounterResultTimestamp :: struct { + timestamp: u64, +} + +DispatchThreadgroupsIndirectArguments :: struct { + threadgroupsPerGrid: [3]u32, +} + +DrawIndexedPrimitivesIndirectArguments :: struct { + indexCount: u32, + instanceCount: u32, + indexStart: u32, + baseVertex: i32, + baseInstance: u32, +} + +DrawPatchIndirectArguments :: struct { + patchCount: u32, + instanceCount: u32, + patchStart: u32, + baseInstance: u32, +} + +DrawPrimitivesIndirectArguments :: struct { + vertexCount: u32, + instanceCount: u32, + vertexStart: u32, + baseInstance: u32, +} + +IndirectCommandBufferExecutionRange :: struct { + location: u32, + length: u32, +} + +MapIndirectArguments :: struct { + regionOriginX: u32, + regionOriginY: u32, + regionOriginZ: u32, + regionSizeWidth: u32, + regionSizeHeight: u32, + regionSizeDepth: u32, + mipMapLevel: u32, + sliceId: u32, +} + +Origin :: distinct [3]NS.Integer + +PackedFloat3 :: distinct [3]f32 + +PackedFloat4x3 :: struct { + columns: [4]PackedFloat3, +} + +QuadTessellationFactorsHalf :: struct { + edgeTessellationFactor: [4]u16, + insideTessellationFactor: [2]u16, +} + +Region :: struct { + origin: Origin, + size: Size, +} + +SamplePosition :: struct { + x: f32, + y: f32, +} + +ScissorRect :: struct { + x: NS.Integer, + y: NS.Integer, + width: NS.Integer, + height: NS.Integer, +} + +Size :: struct { + width: NS.Integer, + height: NS.Integer, + depth: NS.Integer, +} + +SizeAndAlign :: struct { + size: NS.Integer, + align: NS.Integer, +} + +StageInRegionIndirectArguments :: struct { + stageInOrigin: [3]u32, + stageInSize: [3]u32, +} + +TextureSwizzleChannels :: struct { + red: TextureSwizzle, + green: TextureSwizzle, + blue: TextureSwizzle, + alpha: TextureSwizzle, +} + +TriangleTessellationFactorsHalf :: struct { + edgeTessellationFactor: [3]u16, + insideTessellationFactor: u16, +} + +VertexAmplificationViewMapping :: struct { + viewportArrayIndexOffset: u32, + renderTargetArrayIndexOffset: u32, +} + +Viewport :: struct { + originX: f64, + originY: f64, + width: f64, + height: f64, + znear: f64, + zfar: f64, +} + +Timestamp :: distinct u64 + +DeviceNotificationHandler :: distinct rawptr +AutoreleasedComputePipelineReflection :: ^ComputePipelineReflection +AutoreleasedRenderPipelineReflection :: ^RenderPipelineReflection +NewLibraryCompletionHandler :: distinct rawptr +NewRenderPipelineStateCompletionHandler :: distinct rawptr +NewRenderPipelineStateWithReflectionCompletionHandler :: distinct rawptr +NewComputePipelineStateCompletionHandler :: distinct rawptr +NewComputePipelineStateWithReflectionCompletionHandler :: distinct rawptr +SharedEventNotificationBlock :: distinct rawptr + +DrawablePresentedHandler :: distinct rawptr + +AutoreleasedArgument :: ^Argument \ No newline at end of file diff --git a/vendor/Metal/NSBuffer.odin b/vendor/Metal/NSBuffer.odin deleted file mode 100644 index 9f7a83c1a..000000000 --- a/vendor/Metal/NSBuffer.odin +++ /dev/null @@ -1,5 +0,0 @@ -package objc_Metal - -import NS "core:sys/darwin/Foundation" - -Buffer :: struct { using _: Resource } \ No newline at end of file diff --git a/vendor/Metal/NSResource.odin b/vendor/Metal/NSResource.odin deleted file mode 100644 index 34bc0267c..000000000 --- a/vendor/Metal/NSResource.odin +++ /dev/null @@ -1,5 +0,0 @@ -package objc_Metal - -import NS "core:sys/darwin/Foundation" - -Resource :: struct { using _: NS.Object } \ No newline at end of file From ae3b95b194bffc9e9f77e70d4e2b6f33373e39aa Mon Sep 17 00:00:00 2001 From: gingerBill Date: Sat, 12 Feb 2022 17:46:19 +0000 Subject: [PATCH 15/64] `#force_inline` procedures and move foreign procedures to a separate file --- vendor/Metal/MetalClasses.odin | 2652 ++++++++++++++--------------- vendor/Metal/MetalProcedures.odin | 14 + 2 files changed, 1333 insertions(+), 1333 deletions(-) create mode 100644 vendor/Metal/MetalProcedures.odin diff --git a/vendor/Metal/MetalClasses.odin b/vendor/Metal/MetalClasses.odin index 138677d0d..4f788cb55 100644 --- a/vendor/Metal/MetalClasses.odin +++ b/vendor/Metal/MetalClasses.odin @@ -2,20 +2,6 @@ package objc_Metal import NS "core:sys/darwin/Foundation" -foreign import "system:Metal.framework" - -@(default_calling_convention="c", link_prefix="MTL") -foreign Metal { - CopyAllDevices :: proc() -> ^NS.Array --- - CopyAllDevicesWithObserver :: proc(observer: ^^NS.Object, handler: DeviceNotificationHandler) -> ^NS.Array --- - CreateSystemDefaultDevice :: proc() -> ^NS.Object --- - RemoveDeviceObserver :: proc(observer: ^NS.Object) --- -} - - - - - //////////////////////////////////////////////////////////////////////////////// /* @@ -39,47 +25,47 @@ Methods: AccelerationStructureBoundingBoxGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureBoundingBoxGeometryDescriptor) } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_class_name="alloc") -AccelerationStructureBoundingBoxGeometryDescriptor_alloc :: proc() -> ^AccelerationStructureBoundingBoxGeometryDescriptor { +AccelerationStructureBoundingBoxGeometryDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureBoundingBoxGeometryDescriptor { return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, AccelerationStructureBoundingBoxGeometryDescriptor, "alloc") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="init") -AccelerationStructureBoundingBoxGeometryDescriptor_init :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> ^AccelerationStructureBoundingBoxGeometryDescriptor { +AccelerationStructureBoundingBoxGeometryDescriptor_init :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> ^AccelerationStructureBoundingBoxGeometryDescriptor { return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, self, "init") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxBuffer") -AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBuffer :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> ^AccelerationStructureBoundingBoxGeometryDescriptor { +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBuffer :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> ^AccelerationStructureBoundingBoxGeometryDescriptor { return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, self, "boundingBoxBuffer") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxBufferOffset") -AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBufferOffset :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.Integer { +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBufferOffset :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "boundingBoxBufferOffset") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxCount") -AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxCount :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.Integer { +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxCount :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "boundingBoxCount") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxStride") -AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxStride :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.Integer { +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxStride :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "boundingBoxStride") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_class_name="descriptor") -AccelerationStructureBoundingBoxGeometryDescriptor_descriptor :: proc() -> ^AccelerationStructureBoundingBoxGeometryDescriptor { +AccelerationStructureBoundingBoxGeometryDescriptor_descriptor :: #force_inline proc() -> ^AccelerationStructureBoundingBoxGeometryDescriptor { return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, AccelerationStructureBoundingBoxGeometryDescriptor, "descriptor") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxBuffer") -AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBuffer :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBuffer: ^NS.Object) { +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBuffer :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBuffer: ^NS.Object) { msgSend(nil, self, "setBoundingBoxBuffer:", boundingBoxBuffer) } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxBufferOffset") -AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBufferOffset :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBufferOffset: NS.Integer) { +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBufferOffset :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBufferOffset: NS.Integer) { msgSend(nil, self, "setBoundingBoxBufferOffset:", boundingBoxBufferOffset) } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxCount") -AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxCount :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxCount: NS.Integer) { +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxCount :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxCount: NS.Integer) { msgSend(nil, self, "setBoundingBoxCount:", boundingBoxCount) } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxStride") -AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxStride :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxStride: NS.Integer) { +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxStride :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxStride: NS.Integer) { msgSend(nil, self, "setBoundingBoxStride:", boundingBoxStride) } @@ -99,19 +85,19 @@ Methods: AccelerationStructureDescriptor :: struct { using _: NS.Copying(AccelerationStructureDescriptor) } @(objc_type=AccelerationStructureDescriptor, objc_class_name="alloc") -AccelerationStructureDescriptor_alloc :: proc() -> ^AccelerationStructureDescriptor { +AccelerationStructureDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureDescriptor { return msgSend(^AccelerationStructureDescriptor, AccelerationStructureDescriptor, "alloc") } @(objc_type=AccelerationStructureDescriptor, objc_name="init") -AccelerationStructureDescriptor_init :: proc(self: ^AccelerationStructureDescriptor) -> ^AccelerationStructureDescriptor { +AccelerationStructureDescriptor_init :: #force_inline proc(self: ^AccelerationStructureDescriptor) -> ^AccelerationStructureDescriptor { return msgSend(^AccelerationStructureDescriptor, self, "init") } @(objc_type=AccelerationStructureDescriptor, objc_name="setUsage") -AccelerationStructureDescriptor_setUsage :: proc(self: ^AccelerationStructureDescriptor, usage: AccelerationStructureUsage) { +AccelerationStructureDescriptor_setUsage :: #force_inline proc(self: ^AccelerationStructureDescriptor, usage: AccelerationStructureUsage) { msgSend(nil, self, "setUsage:", usage) } @(objc_type=AccelerationStructureDescriptor, objc_name="usage") -AccelerationStructureDescriptor_usage :: proc(self: ^AccelerationStructureDescriptor) -> AccelerationStructureUsage { +AccelerationStructureDescriptor_usage :: #force_inline proc(self: ^AccelerationStructureDescriptor) -> AccelerationStructureUsage { return msgSend(AccelerationStructureUsage, self, "usage") } @@ -135,35 +121,35 @@ Methods: AccelerationStructureGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureGeometryDescriptor) } @(objc_type=AccelerationStructureGeometryDescriptor, objc_class_name="alloc") -AccelerationStructureGeometryDescriptor_alloc :: proc() -> ^AccelerationStructureGeometryDescriptor { +AccelerationStructureGeometryDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureGeometryDescriptor { return msgSend(^AccelerationStructureGeometryDescriptor, AccelerationStructureGeometryDescriptor, "alloc") } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="init") -AccelerationStructureGeometryDescriptor_init :: proc(self: ^AccelerationStructureGeometryDescriptor) -> ^AccelerationStructureGeometryDescriptor { +AccelerationStructureGeometryDescriptor_init :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor) -> ^AccelerationStructureGeometryDescriptor { return msgSend(^AccelerationStructureGeometryDescriptor, self, "init") } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="allowDuplicateIntersectionFunctionInvocation") -AccelerationStructureGeometryDescriptor_allowDuplicateIntersectionFunctionInvocation :: proc(self: ^AccelerationStructureGeometryDescriptor) -> BOOL { +AccelerationStructureGeometryDescriptor_allowDuplicateIntersectionFunctionInvocation :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor) -> BOOL { return msgSend(BOOL, self, "allowDuplicateIntersectionFunctionInvocation") } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="intersectionFunctionTableOffset") -AccelerationStructureGeometryDescriptor_intersectionFunctionTableOffset :: proc(self: ^AccelerationStructureGeometryDescriptor) -> NS.Integer { +AccelerationStructureGeometryDescriptor_intersectionFunctionTableOffset :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "intersectionFunctionTableOffset") } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="opaque") -AccelerationStructureGeometryDescriptor_opaque :: proc(self: ^AccelerationStructureGeometryDescriptor) -> BOOL { +AccelerationStructureGeometryDescriptor_opaque :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor) -> BOOL { return msgSend(BOOL, self, "opaque") } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="setAllowDuplicateIntersectionFunctionInvocation") -AccelerationStructureGeometryDescriptor_setAllowDuplicateIntersectionFunctionInvocation :: proc(self: ^AccelerationStructureGeometryDescriptor, allowDuplicateIntersectionFunctionInvocation: BOOL) { +AccelerationStructureGeometryDescriptor_setAllowDuplicateIntersectionFunctionInvocation :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor, allowDuplicateIntersectionFunctionInvocation: BOOL) { msgSend(nil, self, "setAllowDuplicateIntersectionFunctionInvocation:", allowDuplicateIntersectionFunctionInvocation) } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="setIntersectionFunctionTableOffset") -AccelerationStructureGeometryDescriptor_setIntersectionFunctionTableOffset :: proc(self: ^AccelerationStructureGeometryDescriptor, intersectionFunctionTableOffset: NS.Integer) { +AccelerationStructureGeometryDescriptor_setIntersectionFunctionTableOffset :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor, intersectionFunctionTableOffset: NS.Integer) { msgSend(nil, self, "setIntersectionFunctionTableOffset:", intersectionFunctionTableOffset) } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="setOpaque") -AccelerationStructureGeometryDescriptor_setOpaque :: proc(self: ^AccelerationStructureGeometryDescriptor, opaque: BOOL) { +AccelerationStructureGeometryDescriptor_setOpaque :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor, opaque: BOOL) { msgSend(nil, self, "setOpaque:", opaque) } @@ -196,71 +182,71 @@ Methods: AccelerationStructureTriangleGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureTriangleGeometryDescriptor) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_class_name="alloc") -AccelerationStructureTriangleGeometryDescriptor_alloc :: proc() -> ^AccelerationStructureTriangleGeometryDescriptor { +AccelerationStructureTriangleGeometryDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureTriangleGeometryDescriptor { return msgSend(^AccelerationStructureTriangleGeometryDescriptor, AccelerationStructureTriangleGeometryDescriptor, "alloc") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="init") -AccelerationStructureTriangleGeometryDescriptor_init :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^AccelerationStructureTriangleGeometryDescriptor { +AccelerationStructureTriangleGeometryDescriptor_init :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^AccelerationStructureTriangleGeometryDescriptor { return msgSend(^AccelerationStructureTriangleGeometryDescriptor, self, "init") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_class_name="descriptor") -AccelerationStructureTriangleGeometryDescriptor_descriptor :: proc() -> ^AccelerationStructureTriangleGeometryDescriptor { +AccelerationStructureTriangleGeometryDescriptor_descriptor :: #force_inline proc() -> ^AccelerationStructureTriangleGeometryDescriptor { return msgSend(^AccelerationStructureTriangleGeometryDescriptor, AccelerationStructureTriangleGeometryDescriptor, "descriptor") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="indexBuffer") -AccelerationStructureTriangleGeometryDescriptor_indexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^AccelerationStructureTriangleGeometryDescriptor { +AccelerationStructureTriangleGeometryDescriptor_indexBuffer :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^AccelerationStructureTriangleGeometryDescriptor { return msgSend(^AccelerationStructureTriangleGeometryDescriptor, self, "indexBuffer") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="indexBufferOffset") -AccelerationStructureTriangleGeometryDescriptor_indexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer { +AccelerationStructureTriangleGeometryDescriptor_indexBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "indexBufferOffset") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="indexType") -AccelerationStructureTriangleGeometryDescriptor_indexType :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> IndexType { +AccelerationStructureTriangleGeometryDescriptor_indexType :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> IndexType { return msgSend(IndexType, self, "indexType") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setIndexBuffer") -AccelerationStructureTriangleGeometryDescriptor_setIndexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexBuffer: ^NS.Object) { +AccelerationStructureTriangleGeometryDescriptor_setIndexBuffer :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexBuffer: ^NS.Object) { msgSend(nil, self, "setIndexBuffer:", indexBuffer) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setIndexBufferOffset") -AccelerationStructureTriangleGeometryDescriptor_setIndexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexBufferOffset: NS.Integer) { +AccelerationStructureTriangleGeometryDescriptor_setIndexBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexBufferOffset: NS.Integer) { msgSend(nil, self, "setIndexBufferOffset:", indexBufferOffset) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setIndexType") -AccelerationStructureTriangleGeometryDescriptor_setIndexType :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexType: IndexType) { +AccelerationStructureTriangleGeometryDescriptor_setIndexType :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexType: IndexType) { msgSend(nil, self, "setIndexType:", indexType) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setTriangleCount") -AccelerationStructureTriangleGeometryDescriptor_setTriangleCount :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, triangleCount: NS.Integer) { +AccelerationStructureTriangleGeometryDescriptor_setTriangleCount :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, triangleCount: NS.Integer) { msgSend(nil, self, "setTriangleCount:", triangleCount) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setVertexBuffer") -AccelerationStructureTriangleGeometryDescriptor_setVertexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexBuffer: ^NS.Object) { +AccelerationStructureTriangleGeometryDescriptor_setVertexBuffer :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexBuffer: ^NS.Object) { msgSend(nil, self, "setVertexBuffer:", vertexBuffer) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setVertexBufferOffset") -AccelerationStructureTriangleGeometryDescriptor_setVertexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexBufferOffset: NS.Integer) { +AccelerationStructureTriangleGeometryDescriptor_setVertexBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexBufferOffset: NS.Integer) { msgSend(nil, self, "setVertexBufferOffset:", vertexBufferOffset) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setVertexStride") -AccelerationStructureTriangleGeometryDescriptor_setVertexStride :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexStride: NS.Integer) { +AccelerationStructureTriangleGeometryDescriptor_setVertexStride :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexStride: NS.Integer) { msgSend(nil, self, "setVertexStride:", vertexStride) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="triangleCount") -AccelerationStructureTriangleGeometryDescriptor_triangleCount :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer { +AccelerationStructureTriangleGeometryDescriptor_triangleCount :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "triangleCount") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="vertexBuffer") -AccelerationStructureTriangleGeometryDescriptor_vertexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^AccelerationStructureTriangleGeometryDescriptor { +AccelerationStructureTriangleGeometryDescriptor_vertexBuffer :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^AccelerationStructureTriangleGeometryDescriptor { return msgSend(^AccelerationStructureTriangleGeometryDescriptor, self, "vertexBuffer") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="vertexBufferOffset") -AccelerationStructureTriangleGeometryDescriptor_vertexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer { +AccelerationStructureTriangleGeometryDescriptor_vertexBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "vertexBufferOffset") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="vertexStride") -AccelerationStructureTriangleGeometryDescriptor_vertexStride :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer { +AccelerationStructureTriangleGeometryDescriptor_vertexStride :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "vertexStride") } @@ -294,75 +280,75 @@ Methods: Argument :: struct { using _: NS.Object } @(objc_type=Argument, objc_class_name="alloc") -Argument_alloc :: proc() -> ^Argument { +Argument_alloc :: #force_inline proc() -> ^Argument { return msgSend(^Argument, Argument, "alloc") } @(objc_type=Argument, objc_name="init") -Argument_init :: proc(self: ^Argument) -> ^Argument { +Argument_init :: #force_inline proc(self: ^Argument) -> ^Argument { return msgSend(^Argument, self, "init") } @(objc_type=Argument, objc_name="access") -Argument_access :: proc(self: ^Argument) -> ArgumentAccess { +Argument_access :: #force_inline proc(self: ^Argument) -> ArgumentAccess { return msgSend(ArgumentAccess, self, "access") } @(objc_type=Argument, objc_name="arrayLength") -Argument_arrayLength :: proc(self: ^Argument) -> NS.Integer { +Argument_arrayLength :: #force_inline proc(self: ^Argument) -> NS.Integer { return msgSend(NS.Integer, self, "arrayLength") } @(objc_type=Argument, objc_name="bufferAlignment") -Argument_bufferAlignment :: proc(self: ^Argument) -> NS.Integer { +Argument_bufferAlignment :: #force_inline proc(self: ^Argument) -> NS.Integer { return msgSend(NS.Integer, self, "bufferAlignment") } @(objc_type=Argument, objc_name="bufferDataSize") -Argument_bufferDataSize :: proc(self: ^Argument) -> NS.Integer { +Argument_bufferDataSize :: #force_inline proc(self: ^Argument) -> NS.Integer { return msgSend(NS.Integer, self, "bufferDataSize") } @(objc_type=Argument, objc_name="bufferDataType") -Argument_bufferDataType :: proc(self: ^Argument) -> DataType { +Argument_bufferDataType :: #force_inline proc(self: ^Argument) -> DataType { return msgSend(DataType, self, "bufferDataType") } @(objc_type=Argument, objc_name="bufferPointerType") -Argument_bufferPointerType :: proc(self: ^Argument) -> ^PointerType { +Argument_bufferPointerType :: #force_inline proc(self: ^Argument) -> ^PointerType { return msgSend(^PointerType, self, "bufferPointerType") } @(objc_type=Argument, objc_name="bufferStructType") -Argument_bufferStructType :: proc(self: ^Argument) -> ^StructType { +Argument_bufferStructType :: #force_inline proc(self: ^Argument) -> ^StructType { return msgSend(^StructType, self, "bufferStructType") } @(objc_type=Argument, objc_name="index") -Argument_index :: proc(self: ^Argument) -> NS.Integer { +Argument_index :: #force_inline proc(self: ^Argument) -> NS.Integer { return msgSend(NS.Integer, self, "index") } @(objc_type=Argument, objc_name="isActive") -Argument_isActive :: proc(self: ^Argument) -> BOOL { +Argument_isActive :: #force_inline proc(self: ^Argument) -> BOOL { return msgSend(BOOL, self, "isActive") } @(objc_type=Argument, objc_name="isDepthTexture") -Argument_isDepthTexture :: proc(self: ^Argument) -> BOOL { +Argument_isDepthTexture :: #force_inline proc(self: ^Argument) -> BOOL { return msgSend(BOOL, self, "isDepthTexture") } @(objc_type=Argument, objc_name="name") -Argument_name :: proc(self: ^Argument) -> ^NS.String { +Argument_name :: #force_inline proc(self: ^Argument) -> ^NS.String { return msgSend(^NS.String, self, "name") } @(objc_type=Argument, objc_name="textureDataType") -Argument_textureDataType :: proc(self: ^Argument) -> DataType { +Argument_textureDataType :: #force_inline proc(self: ^Argument) -> DataType { return msgSend(DataType, self, "textureDataType") } @(objc_type=Argument, objc_name="textureType") -Argument_textureType :: proc(self: ^Argument) -> TextureType { +Argument_textureType :: #force_inline proc(self: ^Argument) -> TextureType { return msgSend(TextureType, self, "textureType") } @(objc_type=Argument, objc_name="threadgroupMemoryAlignment") -Argument_threadgroupMemoryAlignment :: proc(self: ^Argument) -> NS.Integer { +Argument_threadgroupMemoryAlignment :: #force_inline proc(self: ^Argument) -> NS.Integer { return msgSend(NS.Integer, self, "threadgroupMemoryAlignment") } @(objc_type=Argument, objc_name="threadgroupMemoryDataSize") -Argument_threadgroupMemoryDataSize :: proc(self: ^Argument) -> NS.Integer { +Argument_threadgroupMemoryDataSize :: #force_inline proc(self: ^Argument) -> NS.Integer { return msgSend(NS.Integer, self, "threadgroupMemoryDataSize") } @(objc_type=Argument, objc_name="type") -Argument_type :: proc(self: ^Argument) -> ArgumentType { +Argument_type :: #force_inline proc(self: ^Argument) -> ArgumentType { return msgSend(ArgumentType, self, "type") } @@ -393,63 +379,63 @@ Methods: ArgumentDescriptor :: struct { using _: NS.Copying(ArgumentDescriptor) } @(objc_type=ArgumentDescriptor, objc_class_name="alloc") -ArgumentDescriptor_alloc :: proc() -> ^ArgumentDescriptor { +ArgumentDescriptor_alloc :: #force_inline proc() -> ^ArgumentDescriptor { return msgSend(^ArgumentDescriptor, ArgumentDescriptor, "alloc") } @(objc_type=ArgumentDescriptor, objc_name="init") -ArgumentDescriptor_init :: proc(self: ^ArgumentDescriptor) -> ^ArgumentDescriptor { +ArgumentDescriptor_init :: #force_inline proc(self: ^ArgumentDescriptor) -> ^ArgumentDescriptor { return msgSend(^ArgumentDescriptor, self, "init") } @(objc_type=ArgumentDescriptor, objc_name="access") -ArgumentDescriptor_access :: proc(self: ^ArgumentDescriptor) -> ArgumentAccess { +ArgumentDescriptor_access :: #force_inline proc(self: ^ArgumentDescriptor) -> ArgumentAccess { return msgSend(ArgumentAccess, self, "access") } @(objc_type=ArgumentDescriptor, objc_class_name="argumentDescriptor") -ArgumentDescriptor_argumentDescriptor :: proc() -> ^ArgumentDescriptor { +ArgumentDescriptor_argumentDescriptor :: #force_inline proc() -> ^ArgumentDescriptor { return msgSend(^ArgumentDescriptor, ArgumentDescriptor, "argumentDescriptor") } @(objc_type=ArgumentDescriptor, objc_name="arrayLength") -ArgumentDescriptor_arrayLength :: proc(self: ^ArgumentDescriptor) -> NS.Integer { +ArgumentDescriptor_arrayLength :: #force_inline proc(self: ^ArgumentDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "arrayLength") } @(objc_type=ArgumentDescriptor, objc_name="constantBlockAlignment") -ArgumentDescriptor_constantBlockAlignment :: proc(self: ^ArgumentDescriptor) -> NS.Integer { +ArgumentDescriptor_constantBlockAlignment :: #force_inline proc(self: ^ArgumentDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "constantBlockAlignment") } @(objc_type=ArgumentDescriptor, objc_name="dataType") -ArgumentDescriptor_dataType :: proc(self: ^ArgumentDescriptor) -> DataType { +ArgumentDescriptor_dataType :: #force_inline proc(self: ^ArgumentDescriptor) -> DataType { return msgSend(DataType, self, "dataType") } @(objc_type=ArgumentDescriptor, objc_name="index") -ArgumentDescriptor_index :: proc(self: ^ArgumentDescriptor) -> NS.Integer { +ArgumentDescriptor_index :: #force_inline proc(self: ^ArgumentDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "index") } @(objc_type=ArgumentDescriptor, objc_name="setAccess") -ArgumentDescriptor_setAccess :: proc(self: ^ArgumentDescriptor, access: ArgumentAccess) { +ArgumentDescriptor_setAccess :: #force_inline proc(self: ^ArgumentDescriptor, access: ArgumentAccess) { msgSend(nil, self, "setAccess:", access) } @(objc_type=ArgumentDescriptor, objc_name="setArrayLength") -ArgumentDescriptor_setArrayLength :: proc(self: ^ArgumentDescriptor, arrayLength: NS.Integer) { +ArgumentDescriptor_setArrayLength :: #force_inline proc(self: ^ArgumentDescriptor, arrayLength: NS.Integer) { msgSend(nil, self, "setArrayLength:", arrayLength) } @(objc_type=ArgumentDescriptor, objc_name="setConstantBlockAlignment") -ArgumentDescriptor_setConstantBlockAlignment :: proc(self: ^ArgumentDescriptor, constantBlockAlignment: NS.Integer) { +ArgumentDescriptor_setConstantBlockAlignment :: #force_inline proc(self: ^ArgumentDescriptor, constantBlockAlignment: NS.Integer) { msgSend(nil, self, "setConstantBlockAlignment:", constantBlockAlignment) } @(objc_type=ArgumentDescriptor, objc_name="setDataType") -ArgumentDescriptor_setDataType :: proc(self: ^ArgumentDescriptor, dataType: DataType) { +ArgumentDescriptor_setDataType :: #force_inline proc(self: ^ArgumentDescriptor, dataType: DataType) { msgSend(nil, self, "setDataType:", dataType) } @(objc_type=ArgumentDescriptor, objc_name="setIndex") -ArgumentDescriptor_setIndex :: proc(self: ^ArgumentDescriptor, index: NS.Integer) { +ArgumentDescriptor_setIndex :: #force_inline proc(self: ^ArgumentDescriptor, index: NS.Integer) { msgSend(nil, self, "setIndex:", index) } @(objc_type=ArgumentDescriptor, objc_name="setTextureType") -ArgumentDescriptor_setTextureType :: proc(self: ^ArgumentDescriptor, textureType: TextureType) { +ArgumentDescriptor_setTextureType :: #force_inline proc(self: ^ArgumentDescriptor, textureType: TextureType) { msgSend(nil, self, "setTextureType:", textureType) } @(objc_type=ArgumentDescriptor, objc_name="textureType") -ArgumentDescriptor_textureType :: proc(self: ^ArgumentDescriptor) -> TextureType { +ArgumentDescriptor_textureType :: #force_inline proc(self: ^ArgumentDescriptor) -> TextureType { return msgSend(TextureType, self, "textureType") } @@ -475,43 +461,43 @@ Methods: ArrayType :: struct { using _: NS.Object } @(objc_type=ArrayType, objc_class_name="alloc") -ArrayType_alloc :: proc() -> ^ArrayType { +ArrayType_alloc :: #force_inline proc() -> ^ArrayType { return msgSend(^ArrayType, ArrayType, "alloc") } @(objc_type=ArrayType, objc_name="init") -ArrayType_init :: proc(self: ^ArrayType) -> ^ArrayType { +ArrayType_init :: #force_inline proc(self: ^ArrayType) -> ^ArrayType { return msgSend(^ArrayType, self, "init") } @(objc_type=ArrayType, objc_name="argumentIndexStride") -ArrayType_argumentIndexStride :: proc(self: ^ArrayType) -> NS.Integer { +ArrayType_argumentIndexStride :: #force_inline proc(self: ^ArrayType) -> NS.Integer { return msgSend(NS.Integer, self, "argumentIndexStride") } @(objc_type=ArrayType, objc_name="arrayLength") -ArrayType_arrayLength :: proc(self: ^ArrayType) -> NS.Integer { +ArrayType_arrayLength :: #force_inline proc(self: ^ArrayType) -> NS.Integer { return msgSend(NS.Integer, self, "arrayLength") } @(objc_type=ArrayType, objc_name="elementArrayType") -ArrayType_elementArrayType :: proc(self: ^ArrayType) -> ^ArrayType { +ArrayType_elementArrayType :: #force_inline proc(self: ^ArrayType) -> ^ArrayType { return msgSend(^ArrayType, self, "elementArrayType") } @(objc_type=ArrayType, objc_name="elementPointerType") -ArrayType_elementPointerType :: proc(self: ^ArrayType) -> ^PointerType { +ArrayType_elementPointerType :: #force_inline proc(self: ^ArrayType) -> ^PointerType { return msgSend(^PointerType, self, "elementPointerType") } @(objc_type=ArrayType, objc_name="elementStructType") -ArrayType_elementStructType :: proc(self: ^ArrayType) -> ^StructType { +ArrayType_elementStructType :: #force_inline proc(self: ^ArrayType) -> ^StructType { return msgSend(^StructType, self, "elementStructType") } @(objc_type=ArrayType, objc_name="elementTextureReferenceType") -ArrayType_elementTextureReferenceType :: proc(self: ^ArrayType) -> ^TextureReferenceType { +ArrayType_elementTextureReferenceType :: #force_inline proc(self: ^ArrayType) -> ^TextureReferenceType { return msgSend(^TextureReferenceType, self, "elementTextureReferenceType") } @(objc_type=ArrayType, objc_name="elementType") -ArrayType_elementType :: proc(self: ^ArrayType) -> DataType { +ArrayType_elementType :: #force_inline proc(self: ^ArrayType) -> DataType { return msgSend(DataType, self, "elementType") } @(objc_type=ArrayType, objc_name="stride") -ArrayType_stride :: proc(self: ^ArrayType) -> NS.Integer { +ArrayType_stride :: #force_inline proc(self: ^ArrayType) -> NS.Integer { return msgSend(NS.Integer, self, "stride") } @@ -535,35 +521,35 @@ Methods: Attribute :: struct { using _: NS.Object } @(objc_type=Attribute, objc_class_name="alloc") -Attribute_alloc :: proc() -> ^Attribute { +Attribute_alloc :: #force_inline proc() -> ^Attribute { return msgSend(^Attribute, Attribute, "alloc") } @(objc_type=Attribute, objc_name="init") -Attribute_init :: proc(self: ^Attribute) -> ^Attribute { +Attribute_init :: #force_inline proc(self: ^Attribute) -> ^Attribute { return msgSend(^Attribute, self, "init") } @(objc_type=Attribute, objc_name="attributeIndex") -Attribute_attributeIndex :: proc(self: ^Attribute) -> NS.Integer { +Attribute_attributeIndex :: #force_inline proc(self: ^Attribute) -> NS.Integer { return msgSend(NS.Integer, self, "attributeIndex") } @(objc_type=Attribute, objc_name="attributeType") -Attribute_attributeType :: proc(self: ^Attribute) -> DataType { +Attribute_attributeType :: #force_inline proc(self: ^Attribute) -> DataType { return msgSend(DataType, self, "attributeType") } @(objc_type=Attribute, objc_name="isActive") -Attribute_isActive :: proc(self: ^Attribute) -> BOOL { +Attribute_isActive :: #force_inline proc(self: ^Attribute) -> BOOL { return msgSend(BOOL, self, "isActive") } @(objc_type=Attribute, objc_name="isPatchControlPointData") -Attribute_isPatchControlPointData :: proc(self: ^Attribute) -> BOOL { +Attribute_isPatchControlPointData :: #force_inline proc(self: ^Attribute) -> BOOL { return msgSend(BOOL, self, "isPatchControlPointData") } @(objc_type=Attribute, objc_name="isPatchData") -Attribute_isPatchData :: proc(self: ^Attribute) -> BOOL { +Attribute_isPatchData :: #force_inline proc(self: ^Attribute) -> BOOL { return msgSend(BOOL, self, "isPatchData") } @(objc_type=Attribute, objc_name="name") -Attribute_name :: proc(self: ^Attribute) -> ^NS.String { +Attribute_name :: #force_inline proc(self: ^Attribute) -> ^NS.String { return msgSend(^NS.String, self, "name") } @@ -587,35 +573,35 @@ Methods: AttributeDescriptor :: struct { using _: NS.Copying(AttributeDescriptor) } @(objc_type=AttributeDescriptor, objc_class_name="alloc") -AttributeDescriptor_alloc :: proc() -> ^AttributeDescriptor { +AttributeDescriptor_alloc :: #force_inline proc() -> ^AttributeDescriptor { return msgSend(^AttributeDescriptor, AttributeDescriptor, "alloc") } @(objc_type=AttributeDescriptor, objc_name="init") -AttributeDescriptor_init :: proc(self: ^AttributeDescriptor) -> ^AttributeDescriptor { +AttributeDescriptor_init :: #force_inline proc(self: ^AttributeDescriptor) -> ^AttributeDescriptor { return msgSend(^AttributeDescriptor, self, "init") } @(objc_type=AttributeDescriptor, objc_name="bufferIndex") -AttributeDescriptor_bufferIndex :: proc(self: ^AttributeDescriptor) -> NS.Integer { +AttributeDescriptor_bufferIndex :: #force_inline proc(self: ^AttributeDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "bufferIndex") } @(objc_type=AttributeDescriptor, objc_name="format") -AttributeDescriptor_format :: proc(self: ^AttributeDescriptor) -> AttributeFormat { +AttributeDescriptor_format :: #force_inline proc(self: ^AttributeDescriptor) -> AttributeFormat { return msgSend(AttributeFormat, self, "format") } @(objc_type=AttributeDescriptor, objc_name="offset") -AttributeDescriptor_offset :: proc(self: ^AttributeDescriptor) -> NS.Integer { +AttributeDescriptor_offset :: #force_inline proc(self: ^AttributeDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "offset") } @(objc_type=AttributeDescriptor, objc_name="setBufferIndex") -AttributeDescriptor_setBufferIndex :: proc(self: ^AttributeDescriptor, bufferIndex: NS.Integer) { +AttributeDescriptor_setBufferIndex :: #force_inline proc(self: ^AttributeDescriptor, bufferIndex: NS.Integer) { msgSend(nil, self, "setBufferIndex:", bufferIndex) } @(objc_type=AttributeDescriptor, objc_name="setFormat") -AttributeDescriptor_setFormat :: proc(self: ^AttributeDescriptor, format: AttributeFormat) { +AttributeDescriptor_setFormat :: #force_inline proc(self: ^AttributeDescriptor, format: AttributeFormat) { msgSend(nil, self, "setFormat:", format) } @(objc_type=AttributeDescriptor, objc_name="setOffset") -AttributeDescriptor_setOffset :: proc(self: ^AttributeDescriptor, offset: NS.Integer) { +AttributeDescriptor_setOffset :: #force_inline proc(self: ^AttributeDescriptor, offset: NS.Integer) { msgSend(nil, self, "setOffset:", offset) } @@ -635,19 +621,19 @@ Methods: AttributeDescriptorArray :: struct { using _: NS.Object } @(objc_type=AttributeDescriptorArray, objc_class_name="alloc") -AttributeDescriptorArray_alloc :: proc() -> ^AttributeDescriptorArray { +AttributeDescriptorArray_alloc :: #force_inline proc() -> ^AttributeDescriptorArray { return msgSend(^AttributeDescriptorArray, AttributeDescriptorArray, "alloc") } @(objc_type=AttributeDescriptorArray, objc_name="init") -AttributeDescriptorArray_init :: proc(self: ^AttributeDescriptorArray) -> ^AttributeDescriptorArray { +AttributeDescriptorArray_init :: #force_inline proc(self: ^AttributeDescriptorArray) -> ^AttributeDescriptorArray { return msgSend(^AttributeDescriptorArray, self, "init") } @(objc_type=AttributeDescriptorArray, objc_name="objectAtIndexedSubscript") -AttributeDescriptorArray_objectAtIndexedSubscript :: proc(self: ^AttributeDescriptorArray, index: ^NS.Object) -> ^AttributeDescriptor { +AttributeDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^AttributeDescriptorArray, index: ^NS.Object) -> ^AttributeDescriptor { return msgSend(^AttributeDescriptor, self, "objectAtIndexedSubscript:", index) } @(objc_type=AttributeDescriptorArray, objc_name="setObject") -AttributeDescriptorArray_setObject :: proc(self: ^AttributeDescriptorArray, attributeDesc: ^AttributeDescriptor, index: ^NS.Object) { +AttributeDescriptorArray_setObject :: #force_inline proc(self: ^AttributeDescriptorArray, attributeDesc: ^AttributeDescriptor, index: ^NS.Object) { msgSend(nil, self, "setObject:atIndexedSubscript:", attributeDesc, index) } @@ -667,19 +653,19 @@ Methods: BinaryArchiveDescriptor :: struct { using _: NS.Copying(BinaryArchiveDescriptor) } @(objc_type=BinaryArchiveDescriptor, objc_class_name="alloc") -BinaryArchiveDescriptor_alloc :: proc() -> ^BinaryArchiveDescriptor { +BinaryArchiveDescriptor_alloc :: #force_inline proc() -> ^BinaryArchiveDescriptor { return msgSend(^BinaryArchiveDescriptor, BinaryArchiveDescriptor, "alloc") } @(objc_type=BinaryArchiveDescriptor, objc_name="init") -BinaryArchiveDescriptor_init :: proc(self: ^BinaryArchiveDescriptor) -> ^BinaryArchiveDescriptor { +BinaryArchiveDescriptor_init :: #force_inline proc(self: ^BinaryArchiveDescriptor) -> ^BinaryArchiveDescriptor { return msgSend(^BinaryArchiveDescriptor, self, "init") } @(objc_type=BinaryArchiveDescriptor, objc_name="setUrl") -BinaryArchiveDescriptor_setUrl :: proc(self: ^BinaryArchiveDescriptor, url: ^NS.URL) { +BinaryArchiveDescriptor_setUrl :: #force_inline proc(self: ^BinaryArchiveDescriptor, url: ^NS.URL) { msgSend(nil, self, "setUrl:", url) } @(objc_type=BinaryArchiveDescriptor, objc_name="url") -BinaryArchiveDescriptor_url :: proc(self: ^BinaryArchiveDescriptor) -> ^NS.URL { +BinaryArchiveDescriptor_url :: #force_inline proc(self: ^BinaryArchiveDescriptor) -> ^NS.URL { return msgSend(^NS.URL, self, "url") } @@ -699,19 +685,19 @@ Methods: BlitPassDescriptor :: struct { using _: NS.Copying(BlitPassDescriptor) } @(objc_type=BlitPassDescriptor, objc_class_name="alloc") -BlitPassDescriptor_alloc :: proc() -> ^BlitPassDescriptor { +BlitPassDescriptor_alloc :: #force_inline proc() -> ^BlitPassDescriptor { return msgSend(^BlitPassDescriptor, BlitPassDescriptor, "alloc") } @(objc_type=BlitPassDescriptor, objc_name="init") -BlitPassDescriptor_init :: proc(self: ^BlitPassDescriptor) -> ^BlitPassDescriptor { +BlitPassDescriptor_init :: #force_inline proc(self: ^BlitPassDescriptor) -> ^BlitPassDescriptor { return msgSend(^BlitPassDescriptor, self, "init") } @(objc_type=BlitPassDescriptor, objc_class_name="blitPassDescriptor") -BlitPassDescriptor_blitPassDescriptor :: proc() -> ^BlitPassDescriptor { +BlitPassDescriptor_blitPassDescriptor :: #force_inline proc() -> ^BlitPassDescriptor { return msgSend(^BlitPassDescriptor, BlitPassDescriptor, "blitPassDescriptor") } @(objc_type=BlitPassDescriptor, objc_name="sampleBufferAttachments") -BlitPassDescriptor_sampleBufferAttachments :: proc(self: ^BlitPassDescriptor) -> ^BlitPassSampleBufferAttachmentDescriptorArray { +BlitPassDescriptor_sampleBufferAttachments :: #force_inline proc(self: ^BlitPassDescriptor) -> ^BlitPassSampleBufferAttachmentDescriptorArray { return msgSend(^BlitPassSampleBufferAttachmentDescriptorArray, self, "sampleBufferAttachments") } @@ -735,35 +721,35 @@ Methods: BlitPassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(BlitPassSampleBufferAttachmentDescriptor) } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_class_name="alloc") -BlitPassSampleBufferAttachmentDescriptor_alloc :: proc() -> ^BlitPassSampleBufferAttachmentDescriptor { +BlitPassSampleBufferAttachmentDescriptor_alloc :: #force_inline proc() -> ^BlitPassSampleBufferAttachmentDescriptor { return msgSend(^BlitPassSampleBufferAttachmentDescriptor, BlitPassSampleBufferAttachmentDescriptor, "alloc") } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="init") -BlitPassSampleBufferAttachmentDescriptor_init :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> ^BlitPassSampleBufferAttachmentDescriptor { +BlitPassSampleBufferAttachmentDescriptor_init :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> ^BlitPassSampleBufferAttachmentDescriptor { return msgSend(^BlitPassSampleBufferAttachmentDescriptor, self, "init") } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="endOfEncoderSampleIndex") -BlitPassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> NS.Integer { +BlitPassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "endOfEncoderSampleIndex") } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") -BlitPassSampleBufferAttachmentDescriptor_sampleBuffer :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> ^BlitPassSampleBufferAttachmentDescriptor { +BlitPassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> ^BlitPassSampleBufferAttachmentDescriptor { return msgSend(^BlitPassSampleBufferAttachmentDescriptor, self, "sampleBuffer") } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex") -BlitPassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.Integer) { +BlitPassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.Integer) { msgSend(nil, self, "setEndOfEncoderSampleIndex:", endOfEncoderSampleIndex) } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") -BlitPassSampleBufferAttachmentDescriptor_setSampleBuffer :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) { +BlitPassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) { msgSend(nil, self, "setSampleBuffer:", sampleBuffer) } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="setStartOfEncoderSampleIndex") -BlitPassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.Integer) { +BlitPassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.Integer) { msgSend(nil, self, "setStartOfEncoderSampleIndex:", startOfEncoderSampleIndex) } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="startOfEncoderSampleIndex") -BlitPassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> NS.Integer { +BlitPassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "startOfEncoderSampleIndex") } @@ -783,19 +769,19 @@ Methods: BlitPassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object } @(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_class_name="alloc") -BlitPassSampleBufferAttachmentDescriptorArray_alloc :: proc() -> ^BlitPassSampleBufferAttachmentDescriptorArray { +BlitPassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^BlitPassSampleBufferAttachmentDescriptorArray { return msgSend(^BlitPassSampleBufferAttachmentDescriptorArray, BlitPassSampleBufferAttachmentDescriptorArray, "alloc") } @(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_name="init") -BlitPassSampleBufferAttachmentDescriptorArray_init :: proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray) -> ^BlitPassSampleBufferAttachmentDescriptorArray { +BlitPassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray) -> ^BlitPassSampleBufferAttachmentDescriptorArray { return msgSend(^BlitPassSampleBufferAttachmentDescriptorArray, self, "init") } @(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -BlitPassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^BlitPassSampleBufferAttachmentDescriptor { +BlitPassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^BlitPassSampleBufferAttachmentDescriptor { return msgSend(^BlitPassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_name="setObject") -BlitPassSampleBufferAttachmentDescriptorArray_setObject :: proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray, attachment: ^BlitPassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) { +BlitPassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray, attachment: ^BlitPassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -819,35 +805,35 @@ Methods: BufferLayoutDescriptor :: struct { using _: NS.Copying(BufferLayoutDescriptor) } @(objc_type=BufferLayoutDescriptor, objc_class_name="alloc") -BufferLayoutDescriptor_alloc :: proc() -> ^BufferLayoutDescriptor { +BufferLayoutDescriptor_alloc :: #force_inline proc() -> ^BufferLayoutDescriptor { return msgSend(^BufferLayoutDescriptor, BufferLayoutDescriptor, "alloc") } @(objc_type=BufferLayoutDescriptor, objc_name="init") -BufferLayoutDescriptor_init :: proc(self: ^BufferLayoutDescriptor) -> ^BufferLayoutDescriptor { +BufferLayoutDescriptor_init :: #force_inline proc(self: ^BufferLayoutDescriptor) -> ^BufferLayoutDescriptor { return msgSend(^BufferLayoutDescriptor, self, "init") } @(objc_type=BufferLayoutDescriptor, objc_name="setStepFunction") -BufferLayoutDescriptor_setStepFunction :: proc(self: ^BufferLayoutDescriptor, stepFunction: StepFunction) { +BufferLayoutDescriptor_setStepFunction :: #force_inline proc(self: ^BufferLayoutDescriptor, stepFunction: StepFunction) { msgSend(nil, self, "setStepFunction:", stepFunction) } @(objc_type=BufferLayoutDescriptor, objc_name="setStepRate") -BufferLayoutDescriptor_setStepRate :: proc(self: ^BufferLayoutDescriptor, stepRate: NS.Integer) { +BufferLayoutDescriptor_setStepRate :: #force_inline proc(self: ^BufferLayoutDescriptor, stepRate: NS.Integer) { msgSend(nil, self, "setStepRate:", stepRate) } @(objc_type=BufferLayoutDescriptor, objc_name="setStride") -BufferLayoutDescriptor_setStride :: proc(self: ^BufferLayoutDescriptor, stride: NS.Integer) { +BufferLayoutDescriptor_setStride :: #force_inline proc(self: ^BufferLayoutDescriptor, stride: NS.Integer) { msgSend(nil, self, "setStride:", stride) } @(objc_type=BufferLayoutDescriptor, objc_name="stepFunction") -BufferLayoutDescriptor_stepFunction :: proc(self: ^BufferLayoutDescriptor) -> StepFunction { +BufferLayoutDescriptor_stepFunction :: #force_inline proc(self: ^BufferLayoutDescriptor) -> StepFunction { return msgSend(StepFunction, self, "stepFunction") } @(objc_type=BufferLayoutDescriptor, objc_name="stepRate") -BufferLayoutDescriptor_stepRate :: proc(self: ^BufferLayoutDescriptor) -> NS.Integer { +BufferLayoutDescriptor_stepRate :: #force_inline proc(self: ^BufferLayoutDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "stepRate") } @(objc_type=BufferLayoutDescriptor, objc_name="stride") -BufferLayoutDescriptor_stride :: proc(self: ^BufferLayoutDescriptor) -> NS.Integer { +BufferLayoutDescriptor_stride :: #force_inline proc(self: ^BufferLayoutDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "stride") } @@ -867,19 +853,19 @@ Methods: BufferLayoutDescriptorArray :: struct { using _: NS.Object } @(objc_type=BufferLayoutDescriptorArray, objc_class_name="alloc") -BufferLayoutDescriptorArray_alloc :: proc() -> ^BufferLayoutDescriptorArray { +BufferLayoutDescriptorArray_alloc :: #force_inline proc() -> ^BufferLayoutDescriptorArray { return msgSend(^BufferLayoutDescriptorArray, BufferLayoutDescriptorArray, "alloc") } @(objc_type=BufferLayoutDescriptorArray, objc_name="init") -BufferLayoutDescriptorArray_init :: proc(self: ^BufferLayoutDescriptorArray) -> ^BufferLayoutDescriptorArray { +BufferLayoutDescriptorArray_init :: #force_inline proc(self: ^BufferLayoutDescriptorArray) -> ^BufferLayoutDescriptorArray { return msgSend(^BufferLayoutDescriptorArray, self, "init") } @(objc_type=BufferLayoutDescriptorArray, objc_name="objectAtIndexedSubscript") -BufferLayoutDescriptorArray_objectAtIndexedSubscript :: proc(self: ^BufferLayoutDescriptorArray, index: ^NS.Object) -> ^BufferLayoutDescriptor { +BufferLayoutDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^BufferLayoutDescriptorArray, index: ^NS.Object) -> ^BufferLayoutDescriptor { return msgSend(^BufferLayoutDescriptor, self, "objectAtIndexedSubscript:", index) } @(objc_type=BufferLayoutDescriptorArray, objc_name="setObject") -BufferLayoutDescriptorArray_setObject :: proc(self: ^BufferLayoutDescriptorArray, bufferDesc: ^BufferLayoutDescriptor, index: ^NS.Object) { +BufferLayoutDescriptorArray_setObject :: #force_inline proc(self: ^BufferLayoutDescriptorArray, bufferDesc: ^BufferLayoutDescriptor, index: ^NS.Object) { msgSend(nil, self, "setObject:atIndexedSubscript:", bufferDesc, index) } @@ -903,35 +889,35 @@ Methods: CaptureDescriptor :: struct { using _: NS.Copying(CaptureDescriptor) } @(objc_type=CaptureDescriptor, objc_class_name="alloc") -CaptureDescriptor_alloc :: proc() -> ^CaptureDescriptor { +CaptureDescriptor_alloc :: #force_inline proc() -> ^CaptureDescriptor { return msgSend(^CaptureDescriptor, CaptureDescriptor, "alloc") } @(objc_type=CaptureDescriptor, objc_name="init") -CaptureDescriptor_init :: proc(self: ^CaptureDescriptor) -> ^CaptureDescriptor { +CaptureDescriptor_init :: #force_inline proc(self: ^CaptureDescriptor) -> ^CaptureDescriptor { return msgSend(^CaptureDescriptor, self, "init") } @(objc_type=CaptureDescriptor, objc_name="captureObject") -CaptureDescriptor_captureObject :: proc(self: ^CaptureDescriptor) -> ^CaptureDescriptor { +CaptureDescriptor_captureObject :: #force_inline proc(self: ^CaptureDescriptor) -> ^CaptureDescriptor { return msgSend(^CaptureDescriptor, self, "captureObject") } @(objc_type=CaptureDescriptor, objc_name="destination") -CaptureDescriptor_destination :: proc(self: ^CaptureDescriptor) -> CaptureDestination { +CaptureDescriptor_destination :: #force_inline proc(self: ^CaptureDescriptor) -> CaptureDestination { return msgSend(CaptureDestination, self, "destination") } @(objc_type=CaptureDescriptor, objc_name="outputURL") -CaptureDescriptor_outputURL :: proc(self: ^CaptureDescriptor) -> ^NS.URL { +CaptureDescriptor_outputURL :: #force_inline proc(self: ^CaptureDescriptor) -> ^NS.URL { return msgSend(^NS.URL, self, "outputURL") } @(objc_type=CaptureDescriptor, objc_name="setCaptureObject") -CaptureDescriptor_setCaptureObject :: proc(self: ^CaptureDescriptor, captureObject: ^NS.Object) { +CaptureDescriptor_setCaptureObject :: #force_inline proc(self: ^CaptureDescriptor, captureObject: ^NS.Object) { msgSend(nil, self, "setCaptureObject:", captureObject) } @(objc_type=CaptureDescriptor, objc_name="setDestination") -CaptureDescriptor_setDestination :: proc(self: ^CaptureDescriptor, destination: CaptureDestination) { +CaptureDescriptor_setDestination :: #force_inline proc(self: ^CaptureDescriptor, destination: CaptureDestination) { msgSend(nil, self, "setDestination:", destination) } @(objc_type=CaptureDescriptor, objc_name="setOutputURL") -CaptureDescriptor_setOutputURL :: proc(self: ^CaptureDescriptor, outputURL: ^NS.URL) { +CaptureDescriptor_setOutputURL :: #force_inline proc(self: ^CaptureDescriptor, outputURL: ^NS.URL) { msgSend(nil, self, "setOutputURL:", outputURL) } @@ -961,59 +947,59 @@ Methods: CaptureManager :: struct { using _: NS.Object } @(objc_type=CaptureManager, objc_class_name="alloc") -CaptureManager_alloc :: proc() -> ^CaptureManager { +CaptureManager_alloc :: #force_inline proc() -> ^CaptureManager { return msgSend(^CaptureManager, CaptureManager, "alloc") } @(objc_type=CaptureManager, objc_name="defaultCaptureScope") -CaptureManager_defaultCaptureScope :: proc(self: ^CaptureManager) -> ^CaptureManager { +CaptureManager_defaultCaptureScope :: #force_inline proc(self: ^CaptureManager) -> ^CaptureManager { return msgSend(^CaptureManager, self, "defaultCaptureScope") } @(objc_type=CaptureManager, objc_name="init") -CaptureManager_init :: proc(self: ^CaptureManager) -> ^CaptureManager { +CaptureManager_init :: #force_inline proc(self: ^CaptureManager) -> ^CaptureManager { return msgSend(^CaptureManager, self, "init") } @(objc_type=CaptureManager, objc_name="isCapturing") -CaptureManager_isCapturing :: proc(self: ^CaptureManager) -> BOOL { +CaptureManager_isCapturing :: #force_inline proc(self: ^CaptureManager) -> BOOL { return msgSend(BOOL, self, "isCapturing") } @(objc_type=CaptureManager, objc_name="newCaptureScopeWithCommandQueue") -CaptureManager_newCaptureScopeWithCommandQueue :: proc(self: ^CaptureManager, commandQueue: ^NS.Object) -> ^CaptureManager { +CaptureManager_newCaptureScopeWithCommandQueue :: #force_inline proc(self: ^CaptureManager, commandQueue: ^NS.Object) -> ^CaptureManager { return msgSend(^CaptureManager, self, "newCaptureScopeWithCommandQueue:", commandQueue) } @(objc_type=CaptureManager, objc_name="newCaptureScopeWithDevice") -CaptureManager_newCaptureScopeWithDevice :: proc(self: ^CaptureManager, device: ^NS.Object) -> ^CaptureManager { +CaptureManager_newCaptureScopeWithDevice :: #force_inline proc(self: ^CaptureManager, device: ^NS.Object) -> ^CaptureManager { return msgSend(^CaptureManager, self, "newCaptureScopeWithDevice:", device) } @(objc_type=CaptureManager, objc_name="setDefaultCaptureScope") -CaptureManager_setDefaultCaptureScope :: proc(self: ^CaptureManager, defaultCaptureScope: ^NS.Object) { +CaptureManager_setDefaultCaptureScope :: #force_inline proc(self: ^CaptureManager, defaultCaptureScope: ^NS.Object) { msgSend(nil, self, "setDefaultCaptureScope:", defaultCaptureScope) } @(objc_type=CaptureManager, objc_class_name="sharedCaptureManager") -CaptureManager_sharedCaptureManager :: proc() -> ^CaptureManager { +CaptureManager_sharedCaptureManager :: #force_inline proc() -> ^CaptureManager { return msgSend(^CaptureManager, CaptureManager, "sharedCaptureManager") } @(objc_type=CaptureManager, objc_name="startCaptureWithCommandQueue") -CaptureManager_startCaptureWithCommandQueue :: proc(self: ^CaptureManager, commandQueue: ^NS.Object) { +CaptureManager_startCaptureWithCommandQueue :: #force_inline proc(self: ^CaptureManager, commandQueue: ^NS.Object) { msgSend(nil, self, "startCaptureWithCommandQueue:", commandQueue) } @(objc_type=CaptureManager, objc_name="startCaptureWithDescriptor") -CaptureManager_startCaptureWithDescriptor :: proc(self: ^CaptureManager, descriptor: ^CaptureDescriptor, error: ^^NS.Error ) -> BOOL { +CaptureManager_startCaptureWithDescriptor :: #force_inline proc(self: ^CaptureManager, descriptor: ^CaptureDescriptor, error: ^^NS.Error ) -> BOOL { return msgSend(BOOL, self, "startCaptureWithDescriptor:error:", descriptor, error) } @(objc_type=CaptureManager, objc_name="startCaptureWithDevice") -CaptureManager_startCaptureWithDevice :: proc(self: ^CaptureManager, device: ^NS.Object) { +CaptureManager_startCaptureWithDevice :: #force_inline proc(self: ^CaptureManager, device: ^NS.Object) { msgSend(nil, self, "startCaptureWithDevice:", device) } @(objc_type=CaptureManager, objc_name="startCaptureWithScope") -CaptureManager_startCaptureWithScope :: proc(self: ^CaptureManager, captureScope: ^NS.Object) { +CaptureManager_startCaptureWithScope :: #force_inline proc(self: ^CaptureManager, captureScope: ^NS.Object) { msgSend(nil, self, "startCaptureWithScope:", captureScope) } @(objc_type=CaptureManager, objc_name="stopCapture") -CaptureManager_stopCapture :: proc(self: ^CaptureManager) { +CaptureManager_stopCapture :: #force_inline proc(self: ^CaptureManager) { msgSend(nil, self, "stopCapture") } @(objc_type=CaptureManager, objc_name="supportsDestination") -CaptureManager_supportsDestination :: proc(self: ^CaptureManager, destination: CaptureDestination) -> BOOL { +CaptureManager_supportsDestination :: #force_inline proc(self: ^CaptureManager, destination: CaptureDestination) -> BOOL { return msgSend(BOOL, self, "supportsDestination:", destination) } @@ -1035,27 +1021,27 @@ Methods: CommandBufferDescriptor :: struct { using _: NS.Copying(CommandBufferDescriptor) } @(objc_type=CommandBufferDescriptor, objc_class_name="alloc") -CommandBufferDescriptor_alloc :: proc() -> ^CommandBufferDescriptor { +CommandBufferDescriptor_alloc :: #force_inline proc() -> ^CommandBufferDescriptor { return msgSend(^CommandBufferDescriptor, CommandBufferDescriptor, "alloc") } @(objc_type=CommandBufferDescriptor, objc_name="init") -CommandBufferDescriptor_init :: proc(self: ^CommandBufferDescriptor) -> ^CommandBufferDescriptor { +CommandBufferDescriptor_init :: #force_inline proc(self: ^CommandBufferDescriptor) -> ^CommandBufferDescriptor { return msgSend(^CommandBufferDescriptor, self, "init") } @(objc_type=CommandBufferDescriptor, objc_name="errorOptions") -CommandBufferDescriptor_errorOptions :: proc(self: ^CommandBufferDescriptor) -> CommandBufferErrorOption { +CommandBufferDescriptor_errorOptions :: #force_inline proc(self: ^CommandBufferDescriptor) -> CommandBufferErrorOption { return msgSend(CommandBufferErrorOption, self, "errorOptions") } @(objc_type=CommandBufferDescriptor, objc_name="retainedReferences") -CommandBufferDescriptor_retainedReferences :: proc(self: ^CommandBufferDescriptor) -> BOOL { +CommandBufferDescriptor_retainedReferences :: #force_inline proc(self: ^CommandBufferDescriptor) -> BOOL { return msgSend(BOOL, self, "retainedReferences") } @(objc_type=CommandBufferDescriptor, objc_name="setErrorOptions") -CommandBufferDescriptor_setErrorOptions :: proc(self: ^CommandBufferDescriptor, errorOptions: CommandBufferErrorOption) { +CommandBufferDescriptor_setErrorOptions :: #force_inline proc(self: ^CommandBufferDescriptor, errorOptions: CommandBufferErrorOption) { msgSend(nil, self, "setErrorOptions:", errorOptions) } @(objc_type=CommandBufferDescriptor, objc_name="setRetainedReferences") -CommandBufferDescriptor_setRetainedReferences :: proc(self: ^CommandBufferDescriptor, retainedReferences: BOOL) { +CommandBufferDescriptor_setRetainedReferences :: #force_inline proc(self: ^CommandBufferDescriptor, retainedReferences: BOOL) { msgSend(nil, self, "setRetainedReferences:", retainedReferences) } @@ -1087,67 +1073,67 @@ Methods: CompileOptions :: struct { using _: NS.Copying(CompileOptions) } @(objc_type=CompileOptions, objc_class_name="alloc") -CompileOptions_alloc :: proc() -> ^CompileOptions { +CompileOptions_alloc :: #force_inline proc() -> ^CompileOptions { return msgSend(^CompileOptions, CompileOptions, "alloc") } @(objc_type=CompileOptions, objc_name="init") -CompileOptions_init :: proc(self: ^CompileOptions) -> ^CompileOptions { +CompileOptions_init :: #force_inline proc(self: ^CompileOptions) -> ^CompileOptions { return msgSend(^CompileOptions, self, "init") } @(objc_type=CompileOptions, objc_name="fastMathEnabled") -CompileOptions_fastMathEnabled :: proc(self: ^CompileOptions) -> BOOL { +CompileOptions_fastMathEnabled :: #force_inline proc(self: ^CompileOptions) -> BOOL { return msgSend(BOOL, self, "fastMathEnabled") } @(objc_type=CompileOptions, objc_name="installName") -CompileOptions_installName :: proc(self: ^CompileOptions) -> ^NS.String { +CompileOptions_installName :: #force_inline proc(self: ^CompileOptions) -> ^NS.String { return msgSend(^NS.String, self, "installName") } @(objc_type=CompileOptions, objc_name="languageVersion") -CompileOptions_languageVersion :: proc(self: ^CompileOptions) -> LanguageVersion { +CompileOptions_languageVersion :: #force_inline proc(self: ^CompileOptions) -> LanguageVersion { return msgSend(LanguageVersion, self, "languageVersion") } @(objc_type=CompileOptions, objc_name="libraries") -CompileOptions_libraries :: proc(self: ^CompileOptions) -> ^NS.Array { +CompileOptions_libraries :: #force_inline proc(self: ^CompileOptions) -> ^NS.Array { return msgSend(^NS.Array, self, "libraries") } @(objc_type=CompileOptions, objc_name="libraryType") -CompileOptions_libraryType :: proc(self: ^CompileOptions) -> LibraryType { +CompileOptions_libraryType :: #force_inline proc(self: ^CompileOptions) -> LibraryType { return msgSend(LibraryType, self, "libraryType") } @(objc_type=CompileOptions, objc_name="preprocessorMacros") -CompileOptions_preprocessorMacros :: proc(self: ^CompileOptions) -> ^NS.Dictionary { +CompileOptions_preprocessorMacros :: #force_inline proc(self: ^CompileOptions) -> ^NS.Dictionary { return msgSend(^NS.Dictionary, self, "preprocessorMacros") } @(objc_type=CompileOptions, objc_name="preserveInvariance") -CompileOptions_preserveInvariance :: proc(self: ^CompileOptions) -> BOOL { +CompileOptions_preserveInvariance :: #force_inline proc(self: ^CompileOptions) -> BOOL { return msgSend(BOOL, self, "preserveInvariance") } @(objc_type=CompileOptions, objc_name="setFastMathEnabled") -CompileOptions_setFastMathEnabled :: proc(self: ^CompileOptions, fastMathEnabled: BOOL) { +CompileOptions_setFastMathEnabled :: #force_inline proc(self: ^CompileOptions, fastMathEnabled: BOOL) { msgSend(nil, self, "setFastMathEnabled:", fastMathEnabled) } @(objc_type=CompileOptions, objc_name="setInstallName") -CompileOptions_setInstallName :: proc(self: ^CompileOptions, installName: ^NS.String) { +CompileOptions_setInstallName :: #force_inline proc(self: ^CompileOptions, installName: ^NS.String) { msgSend(nil, self, "setInstallName:", installName) } @(objc_type=CompileOptions, objc_name="setLanguageVersion") -CompileOptions_setLanguageVersion :: proc(self: ^CompileOptions, languageVersion: LanguageVersion) { +CompileOptions_setLanguageVersion :: #force_inline proc(self: ^CompileOptions, languageVersion: LanguageVersion) { msgSend(nil, self, "setLanguageVersion:", languageVersion) } @(objc_type=CompileOptions, objc_name="setLibraries") -CompileOptions_setLibraries :: proc(self: ^CompileOptions, libraries: ^NS.Array) { +CompileOptions_setLibraries :: #force_inline proc(self: ^CompileOptions, libraries: ^NS.Array) { msgSend(nil, self, "setLibraries:", libraries) } @(objc_type=CompileOptions, objc_name="setLibraryType") -CompileOptions_setLibraryType :: proc(self: ^CompileOptions, libraryType: LibraryType) { +CompileOptions_setLibraryType :: #force_inline proc(self: ^CompileOptions, libraryType: LibraryType) { msgSend(nil, self, "setLibraryType:", libraryType) } @(objc_type=CompileOptions, objc_name="setPreprocessorMacros") -CompileOptions_setPreprocessorMacros :: proc(self: ^CompileOptions, preprocessorMacros: ^NS.Dictionary) { +CompileOptions_setPreprocessorMacros :: #force_inline proc(self: ^CompileOptions, preprocessorMacros: ^NS.Dictionary) { msgSend(nil, self, "setPreprocessorMacros:", preprocessorMacros) } @(objc_type=CompileOptions, objc_name="setPreserveInvariance") -CompileOptions_setPreserveInvariance :: proc(self: ^CompileOptions, preserveInvariance: BOOL) { +CompileOptions_setPreserveInvariance :: #force_inline proc(self: ^CompileOptions, preserveInvariance: BOOL) { msgSend(nil, self, "setPreserveInvariance:", preserveInvariance) } @@ -1169,27 +1155,27 @@ Methods: ComputePassDescriptor :: struct { using _: NS.Copying(ComputePassDescriptor) } @(objc_type=ComputePassDescriptor, objc_class_name="alloc") -ComputePassDescriptor_alloc :: proc() -> ^ComputePassDescriptor { +ComputePassDescriptor_alloc :: #force_inline proc() -> ^ComputePassDescriptor { return msgSend(^ComputePassDescriptor, ComputePassDescriptor, "alloc") } @(objc_type=ComputePassDescriptor, objc_name="init") -ComputePassDescriptor_init :: proc(self: ^ComputePassDescriptor) -> ^ComputePassDescriptor { +ComputePassDescriptor_init :: #force_inline proc(self: ^ComputePassDescriptor) -> ^ComputePassDescriptor { return msgSend(^ComputePassDescriptor, self, "init") } @(objc_type=ComputePassDescriptor, objc_class_name="computePassDescriptor") -ComputePassDescriptor_computePassDescriptor :: proc() -> ^ComputePassDescriptor { +ComputePassDescriptor_computePassDescriptor :: #force_inline proc() -> ^ComputePassDescriptor { return msgSend(^ComputePassDescriptor, ComputePassDescriptor, "computePassDescriptor") } @(objc_type=ComputePassDescriptor, objc_name="dispatchType") -ComputePassDescriptor_dispatchType :: proc(self: ^ComputePassDescriptor) -> DispatchType { +ComputePassDescriptor_dispatchType :: #force_inline proc(self: ^ComputePassDescriptor) -> DispatchType { return msgSend(DispatchType, self, "dispatchType") } @(objc_type=ComputePassDescriptor, objc_name="sampleBufferAttachments") -ComputePassDescriptor_sampleBufferAttachments :: proc(self: ^ComputePassDescriptor) -> ^ComputePassSampleBufferAttachmentDescriptorArray { +ComputePassDescriptor_sampleBufferAttachments :: #force_inline proc(self: ^ComputePassDescriptor) -> ^ComputePassSampleBufferAttachmentDescriptorArray { return msgSend(^ComputePassSampleBufferAttachmentDescriptorArray, self, "sampleBufferAttachments") } @(objc_type=ComputePassDescriptor, objc_name="setDispatchType") -ComputePassDescriptor_setDispatchType :: proc(self: ^ComputePassDescriptor, dispatchType: DispatchType) { +ComputePassDescriptor_setDispatchType :: #force_inline proc(self: ^ComputePassDescriptor, dispatchType: DispatchType) { msgSend(nil, self, "setDispatchType:", dispatchType) } @@ -1213,35 +1199,35 @@ Methods: ComputePassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(ComputePassSampleBufferAttachmentDescriptor) } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_class_name="alloc") -ComputePassSampleBufferAttachmentDescriptor_alloc :: proc() -> ^ComputePassSampleBufferAttachmentDescriptor { +ComputePassSampleBufferAttachmentDescriptor_alloc :: #force_inline proc() -> ^ComputePassSampleBufferAttachmentDescriptor { return msgSend(^ComputePassSampleBufferAttachmentDescriptor, ComputePassSampleBufferAttachmentDescriptor, "alloc") } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="init") -ComputePassSampleBufferAttachmentDescriptor_init :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> ^ComputePassSampleBufferAttachmentDescriptor { +ComputePassSampleBufferAttachmentDescriptor_init :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> ^ComputePassSampleBufferAttachmentDescriptor { return msgSend(^ComputePassSampleBufferAttachmentDescriptor, self, "init") } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="endOfEncoderSampleIndex") -ComputePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> NS.Integer { +ComputePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "endOfEncoderSampleIndex") } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") -ComputePassSampleBufferAttachmentDescriptor_sampleBuffer :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> ^ComputePassSampleBufferAttachmentDescriptor { +ComputePassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> ^ComputePassSampleBufferAttachmentDescriptor { return msgSend(^ComputePassSampleBufferAttachmentDescriptor, self, "sampleBuffer") } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex") -ComputePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.Integer) { +ComputePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.Integer) { msgSend(nil, self, "setEndOfEncoderSampleIndex:", endOfEncoderSampleIndex) } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") -ComputePassSampleBufferAttachmentDescriptor_setSampleBuffer :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) { +ComputePassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) { msgSend(nil, self, "setSampleBuffer:", sampleBuffer) } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="setStartOfEncoderSampleIndex") -ComputePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.Integer) { +ComputePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.Integer) { msgSend(nil, self, "setStartOfEncoderSampleIndex:", startOfEncoderSampleIndex) } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="startOfEncoderSampleIndex") -ComputePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> NS.Integer { +ComputePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "startOfEncoderSampleIndex") } @@ -1261,19 +1247,19 @@ Methods: ComputePassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object } @(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_class_name="alloc") -ComputePassSampleBufferAttachmentDescriptorArray_alloc :: proc() -> ^ComputePassSampleBufferAttachmentDescriptorArray { +ComputePassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^ComputePassSampleBufferAttachmentDescriptorArray { return msgSend(^ComputePassSampleBufferAttachmentDescriptorArray, ComputePassSampleBufferAttachmentDescriptorArray, "alloc") } @(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_name="init") -ComputePassSampleBufferAttachmentDescriptorArray_init :: proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray) -> ^ComputePassSampleBufferAttachmentDescriptorArray { +ComputePassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray) -> ^ComputePassSampleBufferAttachmentDescriptorArray { return msgSend(^ComputePassSampleBufferAttachmentDescriptorArray, self, "init") } @(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -ComputePassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^ComputePassSampleBufferAttachmentDescriptor { +ComputePassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^ComputePassSampleBufferAttachmentDescriptor { return msgSend(^ComputePassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_name="setObject") -ComputePassSampleBufferAttachmentDescriptorArray_setObject :: proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray, attachment: ^ComputePassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) { +ComputePassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray, attachment: ^ComputePassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -1315,107 +1301,107 @@ Methods: ComputePipelineDescriptor :: struct { using _: NS.Copying(ComputePipelineDescriptor) } @(objc_type=ComputePipelineDescriptor, objc_class_name="alloc") -ComputePipelineDescriptor_alloc :: proc() -> ^ComputePipelineDescriptor { +ComputePipelineDescriptor_alloc :: #force_inline proc() -> ^ComputePipelineDescriptor { return msgSend(^ComputePipelineDescriptor, ComputePipelineDescriptor, "alloc") } @(objc_type=ComputePipelineDescriptor, objc_name="init") -ComputePipelineDescriptor_init :: proc(self: ^ComputePipelineDescriptor) -> ^ComputePipelineDescriptor { +ComputePipelineDescriptor_init :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ^ComputePipelineDescriptor { return msgSend(^ComputePipelineDescriptor, self, "init") } @(objc_type=ComputePipelineDescriptor, objc_name="binaryArchives") -ComputePipelineDescriptor_binaryArchives :: proc(self: ^ComputePipelineDescriptor) -> ^NS.Array { +ComputePipelineDescriptor_binaryArchives :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ^NS.Array { return msgSend(^NS.Array, self, "binaryArchives") } @(objc_type=ComputePipelineDescriptor, objc_name="buffers") -ComputePipelineDescriptor_buffers :: proc(self: ^ComputePipelineDescriptor) -> ^PipelineBufferDescriptorArray { +ComputePipelineDescriptor_buffers :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ^PipelineBufferDescriptorArray { return msgSend(^PipelineBufferDescriptorArray, self, "buffers") } @(objc_type=ComputePipelineDescriptor, objc_name="computeFunction") -ComputePipelineDescriptor_computeFunction :: proc(self: ^ComputePipelineDescriptor) -> ^ComputePipelineDescriptor { +ComputePipelineDescriptor_computeFunction :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ^ComputePipelineDescriptor { return msgSend(^ComputePipelineDescriptor, self, "computeFunction") } @(objc_type=ComputePipelineDescriptor, objc_name="insertLibraries") -ComputePipelineDescriptor_insertLibraries :: proc(self: ^ComputePipelineDescriptor) -> ^NS.Array { +ComputePipelineDescriptor_insertLibraries :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ^NS.Array { return msgSend(^NS.Array, self, "insertLibraries") } @(objc_type=ComputePipelineDescriptor, objc_name="label") -ComputePipelineDescriptor_label :: proc(self: ^ComputePipelineDescriptor) -> ^NS.String { +ComputePipelineDescriptor_label :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=ComputePipelineDescriptor, objc_name="linkedFunctions") -ComputePipelineDescriptor_linkedFunctions :: proc(self: ^ComputePipelineDescriptor) -> ^LinkedFunctions { +ComputePipelineDescriptor_linkedFunctions :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ^LinkedFunctions { return msgSend(^LinkedFunctions, self, "linkedFunctions") } @(objc_type=ComputePipelineDescriptor, objc_name="maxCallStackDepth") -ComputePipelineDescriptor_maxCallStackDepth :: proc(self: ^ComputePipelineDescriptor) -> NS.Integer { +ComputePipelineDescriptor_maxCallStackDepth :: #force_inline proc(self: ^ComputePipelineDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "maxCallStackDepth") } @(objc_type=ComputePipelineDescriptor, objc_name="maxTotalThreadsPerThreadgroup") -ComputePipelineDescriptor_maxTotalThreadsPerThreadgroup :: proc(self: ^ComputePipelineDescriptor) -> NS.Integer { +ComputePipelineDescriptor_maxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^ComputePipelineDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "maxTotalThreadsPerThreadgroup") } @(objc_type=ComputePipelineDescriptor, objc_name="reset") -ComputePipelineDescriptor_reset :: proc(self: ^ComputePipelineDescriptor) { +ComputePipelineDescriptor_reset :: #force_inline proc(self: ^ComputePipelineDescriptor) { msgSend(nil, self, "reset") } @(objc_type=ComputePipelineDescriptor, objc_name="setBinaryArchives") -ComputePipelineDescriptor_setBinaryArchives :: proc(self: ^ComputePipelineDescriptor, binaryArchives: ^NS.Array) { +ComputePipelineDescriptor_setBinaryArchives :: #force_inline proc(self: ^ComputePipelineDescriptor, binaryArchives: ^NS.Array) { msgSend(nil, self, "setBinaryArchives:", binaryArchives) } @(objc_type=ComputePipelineDescriptor, objc_name="setComputeFunction") -ComputePipelineDescriptor_setComputeFunction :: proc(self: ^ComputePipelineDescriptor, computeFunction: ^NS.Object) { +ComputePipelineDescriptor_setComputeFunction :: #force_inline proc(self: ^ComputePipelineDescriptor, computeFunction: ^NS.Object) { msgSend(nil, self, "setComputeFunction:", computeFunction) } @(objc_type=ComputePipelineDescriptor, objc_name="setInsertLibraries") -ComputePipelineDescriptor_setInsertLibraries :: proc(self: ^ComputePipelineDescriptor, insertLibraries: ^NS.Array) { +ComputePipelineDescriptor_setInsertLibraries :: #force_inline proc(self: ^ComputePipelineDescriptor, insertLibraries: ^NS.Array) { msgSend(nil, self, "setInsertLibraries:", insertLibraries) } @(objc_type=ComputePipelineDescriptor, objc_name="setLabel") -ComputePipelineDescriptor_setLabel :: proc(self: ^ComputePipelineDescriptor, label: ^NS.String) { +ComputePipelineDescriptor_setLabel :: #force_inline proc(self: ^ComputePipelineDescriptor, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=ComputePipelineDescriptor, objc_name="setLinkedFunctions") -ComputePipelineDescriptor_setLinkedFunctions :: proc(self: ^ComputePipelineDescriptor, linkedFunctions: ^LinkedFunctions) { +ComputePipelineDescriptor_setLinkedFunctions :: #force_inline proc(self: ^ComputePipelineDescriptor, linkedFunctions: ^LinkedFunctions) { msgSend(nil, self, "setLinkedFunctions:", linkedFunctions) } @(objc_type=ComputePipelineDescriptor, objc_name="setMaxCallStackDepth") -ComputePipelineDescriptor_setMaxCallStackDepth :: proc(self: ^ComputePipelineDescriptor, maxCallStackDepth: NS.Integer) { +ComputePipelineDescriptor_setMaxCallStackDepth :: #force_inline proc(self: ^ComputePipelineDescriptor, maxCallStackDepth: NS.Integer) { msgSend(nil, self, "setMaxCallStackDepth:", maxCallStackDepth) } @(objc_type=ComputePipelineDescriptor, objc_name="setMaxTotalThreadsPerThreadgroup") -ComputePipelineDescriptor_setMaxTotalThreadsPerThreadgroup :: proc(self: ^ComputePipelineDescriptor, maxTotalThreadsPerThreadgroup: NS.Integer) { +ComputePipelineDescriptor_setMaxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^ComputePipelineDescriptor, maxTotalThreadsPerThreadgroup: NS.Integer) { msgSend(nil, self, "setMaxTotalThreadsPerThreadgroup:", maxTotalThreadsPerThreadgroup) } @(objc_type=ComputePipelineDescriptor, objc_name="setStageInputDescriptor") -ComputePipelineDescriptor_setStageInputDescriptor :: proc(self: ^ComputePipelineDescriptor, stageInputDescriptor: ^StageInputOutputDescriptor) { +ComputePipelineDescriptor_setStageInputDescriptor :: #force_inline proc(self: ^ComputePipelineDescriptor, stageInputDescriptor: ^StageInputOutputDescriptor) { msgSend(nil, self, "setStageInputDescriptor:", stageInputDescriptor) } @(objc_type=ComputePipelineDescriptor, objc_name="setSupportAddingBinaryFunctions") -ComputePipelineDescriptor_setSupportAddingBinaryFunctions :: proc(self: ^ComputePipelineDescriptor, supportAddingBinaryFunctions: BOOL) { +ComputePipelineDescriptor_setSupportAddingBinaryFunctions :: #force_inline proc(self: ^ComputePipelineDescriptor, supportAddingBinaryFunctions: BOOL) { msgSend(nil, self, "setSupportAddingBinaryFunctions:", supportAddingBinaryFunctions) } @(objc_type=ComputePipelineDescriptor, objc_name="setSupportIndirectCommandBuffers") -ComputePipelineDescriptor_setSupportIndirectCommandBuffers :: proc(self: ^ComputePipelineDescriptor, supportIndirectCommandBuffers: BOOL) { +ComputePipelineDescriptor_setSupportIndirectCommandBuffers :: #force_inline proc(self: ^ComputePipelineDescriptor, supportIndirectCommandBuffers: BOOL) { msgSend(nil, self, "setSupportIndirectCommandBuffers:", supportIndirectCommandBuffers) } @(objc_type=ComputePipelineDescriptor, objc_name="setThreadGroupSizeIsMultipleOfThreadExecutionWidth") -ComputePipelineDescriptor_setThreadGroupSizeIsMultipleOfThreadExecutionWidth :: proc(self: ^ComputePipelineDescriptor, threadGroupSizeIsMultipleOfThreadExecutionWidth: BOOL) { +ComputePipelineDescriptor_setThreadGroupSizeIsMultipleOfThreadExecutionWidth :: #force_inline proc(self: ^ComputePipelineDescriptor, threadGroupSizeIsMultipleOfThreadExecutionWidth: BOOL) { msgSend(nil, self, "setThreadGroupSizeIsMultipleOfThreadExecutionWidth:", threadGroupSizeIsMultipleOfThreadExecutionWidth) } @(objc_type=ComputePipelineDescriptor, objc_name="stageInputDescriptor") -ComputePipelineDescriptor_stageInputDescriptor :: proc(self: ^ComputePipelineDescriptor) -> ^StageInputOutputDescriptor { +ComputePipelineDescriptor_stageInputDescriptor :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ^StageInputOutputDescriptor { return msgSend(^StageInputOutputDescriptor, self, "stageInputDescriptor") } @(objc_type=ComputePipelineDescriptor, objc_name="supportAddingBinaryFunctions") -ComputePipelineDescriptor_supportAddingBinaryFunctions :: proc(self: ^ComputePipelineDescriptor) -> BOOL { +ComputePipelineDescriptor_supportAddingBinaryFunctions :: #force_inline proc(self: ^ComputePipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "supportAddingBinaryFunctions") } @(objc_type=ComputePipelineDescriptor, objc_name="supportIndirectCommandBuffers") -ComputePipelineDescriptor_supportIndirectCommandBuffers :: proc(self: ^ComputePipelineDescriptor) -> BOOL { +ComputePipelineDescriptor_supportIndirectCommandBuffers :: #force_inline proc(self: ^ComputePipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "supportIndirectCommandBuffers") } @(objc_type=ComputePipelineDescriptor, objc_name="threadGroupSizeIsMultipleOfThreadExecutionWidth") -ComputePipelineDescriptor_threadGroupSizeIsMultipleOfThreadExecutionWidth :: proc(self: ^ComputePipelineDescriptor) -> BOOL { +ComputePipelineDescriptor_threadGroupSizeIsMultipleOfThreadExecutionWidth :: #force_inline proc(self: ^ComputePipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "threadGroupSizeIsMultipleOfThreadExecutionWidth") } @@ -1434,15 +1420,15 @@ Methods: ComputePipelineReflection :: struct { using _: NS.Object } @(objc_type=ComputePipelineReflection, objc_class_name="alloc") -ComputePipelineReflection_alloc :: proc() -> ^ComputePipelineReflection { +ComputePipelineReflection_alloc :: #force_inline proc() -> ^ComputePipelineReflection { return msgSend(^ComputePipelineReflection, ComputePipelineReflection, "alloc") } @(objc_type=ComputePipelineReflection, objc_name="init") -ComputePipelineReflection_init :: proc(self: ^ComputePipelineReflection) -> ^ComputePipelineReflection { +ComputePipelineReflection_init :: #force_inline proc(self: ^ComputePipelineReflection) -> ^ComputePipelineReflection { return msgSend(^ComputePipelineReflection, self, "init") } @(objc_type=ComputePipelineReflection, objc_name="arguments") -ComputePipelineReflection_arguments :: proc(self: ^ComputePipelineReflection) -> ^NS.Array { +ComputePipelineReflection_arguments :: #force_inline proc(self: ^ComputePipelineReflection) -> ^NS.Array { return msgSend(^NS.Array, self, "arguments") } @@ -1468,43 +1454,43 @@ Methods: CounterSampleBufferDescriptor :: struct { using _: NS.Copying(CounterSampleBufferDescriptor) } @(objc_type=CounterSampleBufferDescriptor, objc_class_name="alloc") -CounterSampleBufferDescriptor_alloc :: proc() -> ^CounterSampleBufferDescriptor { +CounterSampleBufferDescriptor_alloc :: #force_inline proc() -> ^CounterSampleBufferDescriptor { return msgSend(^CounterSampleBufferDescriptor, CounterSampleBufferDescriptor, "alloc") } @(objc_type=CounterSampleBufferDescriptor, objc_name="init") -CounterSampleBufferDescriptor_init :: proc(self: ^CounterSampleBufferDescriptor) -> ^CounterSampleBufferDescriptor { +CounterSampleBufferDescriptor_init :: #force_inline proc(self: ^CounterSampleBufferDescriptor) -> ^CounterSampleBufferDescriptor { return msgSend(^CounterSampleBufferDescriptor, self, "init") } @(objc_type=CounterSampleBufferDescriptor, objc_name="counterSet") -CounterSampleBufferDescriptor_counterSet :: proc(self: ^CounterSampleBufferDescriptor) -> ^CounterSampleBufferDescriptor { +CounterSampleBufferDescriptor_counterSet :: #force_inline proc(self: ^CounterSampleBufferDescriptor) -> ^CounterSampleBufferDescriptor { return msgSend(^CounterSampleBufferDescriptor, self, "counterSet") } @(objc_type=CounterSampleBufferDescriptor, objc_name="label") -CounterSampleBufferDescriptor_label :: proc(self: ^CounterSampleBufferDescriptor) -> ^NS.String { +CounterSampleBufferDescriptor_label :: #force_inline proc(self: ^CounterSampleBufferDescriptor) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=CounterSampleBufferDescriptor, objc_name="sampleCount") -CounterSampleBufferDescriptor_sampleCount :: proc(self: ^CounterSampleBufferDescriptor) -> NS.Integer { +CounterSampleBufferDescriptor_sampleCount :: #force_inline proc(self: ^CounterSampleBufferDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "sampleCount") } @(objc_type=CounterSampleBufferDescriptor, objc_name="setCounterSet") -CounterSampleBufferDescriptor_setCounterSet :: proc(self: ^CounterSampleBufferDescriptor, counterSet: ^NS.Object) { +CounterSampleBufferDescriptor_setCounterSet :: #force_inline proc(self: ^CounterSampleBufferDescriptor, counterSet: ^NS.Object) { msgSend(nil, self, "setCounterSet:", counterSet) } @(objc_type=CounterSampleBufferDescriptor, objc_name="setLabel") -CounterSampleBufferDescriptor_setLabel :: proc(self: ^CounterSampleBufferDescriptor, label: ^NS.String) { +CounterSampleBufferDescriptor_setLabel :: #force_inline proc(self: ^CounterSampleBufferDescriptor, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=CounterSampleBufferDescriptor, objc_name="setSampleCount") -CounterSampleBufferDescriptor_setSampleCount :: proc(self: ^CounterSampleBufferDescriptor, sampleCount: NS.Integer) { +CounterSampleBufferDescriptor_setSampleCount :: #force_inline proc(self: ^CounterSampleBufferDescriptor, sampleCount: NS.Integer) { msgSend(nil, self, "setSampleCount:", sampleCount) } @(objc_type=CounterSampleBufferDescriptor, objc_name="setStorageMode") -CounterSampleBufferDescriptor_setStorageMode :: proc(self: ^CounterSampleBufferDescriptor, storageMode: StorageMode) { +CounterSampleBufferDescriptor_setStorageMode :: #force_inline proc(self: ^CounterSampleBufferDescriptor, storageMode: StorageMode) { msgSend(nil, self, "setStorageMode:", storageMode) } @(objc_type=CounterSampleBufferDescriptor, objc_name="storageMode") -CounterSampleBufferDescriptor_storageMode :: proc(self: ^CounterSampleBufferDescriptor) -> StorageMode { +CounterSampleBufferDescriptor_storageMode :: #force_inline proc(self: ^CounterSampleBufferDescriptor) -> StorageMode { return msgSend(StorageMode, self, "storageMode") } @@ -1532,51 +1518,51 @@ Methods: DepthStencilDescriptor :: struct { using _: NS.Copying(DepthStencilDescriptor) } @(objc_type=DepthStencilDescriptor, objc_class_name="alloc") -DepthStencilDescriptor_alloc :: proc() -> ^DepthStencilDescriptor { +DepthStencilDescriptor_alloc :: #force_inline proc() -> ^DepthStencilDescriptor { return msgSend(^DepthStencilDescriptor, DepthStencilDescriptor, "alloc") } @(objc_type=DepthStencilDescriptor, objc_name="init") -DepthStencilDescriptor_init :: proc(self: ^DepthStencilDescriptor) -> ^DepthStencilDescriptor { +DepthStencilDescriptor_init :: #force_inline proc(self: ^DepthStencilDescriptor) -> ^DepthStencilDescriptor { return msgSend(^DepthStencilDescriptor, self, "init") } @(objc_type=DepthStencilDescriptor, objc_name="backFaceStencil") -DepthStencilDescriptor_backFaceStencil :: proc(self: ^DepthStencilDescriptor) -> ^StencilDescriptor { +DepthStencilDescriptor_backFaceStencil :: #force_inline proc(self: ^DepthStencilDescriptor) -> ^StencilDescriptor { return msgSend(^StencilDescriptor, self, "backFaceStencil") } @(objc_type=DepthStencilDescriptor, objc_name="depthCompareFunction") -DepthStencilDescriptor_depthCompareFunction :: proc(self: ^DepthStencilDescriptor) -> CompareFunction { +DepthStencilDescriptor_depthCompareFunction :: #force_inline proc(self: ^DepthStencilDescriptor) -> CompareFunction { return msgSend(CompareFunction, self, "depthCompareFunction") } @(objc_type=DepthStencilDescriptor, objc_name="frontFaceStencil") -DepthStencilDescriptor_frontFaceStencil :: proc(self: ^DepthStencilDescriptor) -> ^StencilDescriptor { +DepthStencilDescriptor_frontFaceStencil :: #force_inline proc(self: ^DepthStencilDescriptor) -> ^StencilDescriptor { return msgSend(^StencilDescriptor, self, "frontFaceStencil") } @(objc_type=DepthStencilDescriptor, objc_name="isDepthWriteEnabled") -DepthStencilDescriptor_isDepthWriteEnabled :: proc(self: ^DepthStencilDescriptor) -> BOOL { +DepthStencilDescriptor_isDepthWriteEnabled :: #force_inline proc(self: ^DepthStencilDescriptor) -> BOOL { return msgSend(BOOL, self, "isDepthWriteEnabled") } @(objc_type=DepthStencilDescriptor, objc_name="label") -DepthStencilDescriptor_label :: proc(self: ^DepthStencilDescriptor) -> ^NS.String { +DepthStencilDescriptor_label :: #force_inline proc(self: ^DepthStencilDescriptor) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=DepthStencilDescriptor, objc_name="setBackFaceStencil") -DepthStencilDescriptor_setBackFaceStencil :: proc(self: ^DepthStencilDescriptor, backFaceStencil: ^StencilDescriptor) { +DepthStencilDescriptor_setBackFaceStencil :: #force_inline proc(self: ^DepthStencilDescriptor, backFaceStencil: ^StencilDescriptor) { msgSend(nil, self, "setBackFaceStencil:", backFaceStencil) } @(objc_type=DepthStencilDescriptor, objc_name="setDepthCompareFunction") -DepthStencilDescriptor_setDepthCompareFunction :: proc(self: ^DepthStencilDescriptor, depthCompareFunction: CompareFunction) { +DepthStencilDescriptor_setDepthCompareFunction :: #force_inline proc(self: ^DepthStencilDescriptor, depthCompareFunction: CompareFunction) { msgSend(nil, self, "setDepthCompareFunction:", depthCompareFunction) } @(objc_type=DepthStencilDescriptor, objc_name="setDepthWriteEnabled") -DepthStencilDescriptor_setDepthWriteEnabled :: proc(self: ^DepthStencilDescriptor, depthWriteEnabled: BOOL) { +DepthStencilDescriptor_setDepthWriteEnabled :: #force_inline proc(self: ^DepthStencilDescriptor, depthWriteEnabled: BOOL) { msgSend(nil, self, "setDepthWriteEnabled:", depthWriteEnabled) } @(objc_type=DepthStencilDescriptor, objc_name="setFrontFaceStencil") -DepthStencilDescriptor_setFrontFaceStencil :: proc(self: ^DepthStencilDescriptor, frontFaceStencil: ^StencilDescriptor) { +DepthStencilDescriptor_setFrontFaceStencil :: #force_inline proc(self: ^DepthStencilDescriptor, frontFaceStencil: ^StencilDescriptor) { msgSend(nil, self, "setFrontFaceStencil:", frontFaceStencil) } @(objc_type=DepthStencilDescriptor, objc_name="setLabel") -DepthStencilDescriptor_setLabel :: proc(self: ^DepthStencilDescriptor, label: ^NS.String) { +DepthStencilDescriptor_setLabel :: #force_inline proc(self: ^DepthStencilDescriptor, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @@ -1598,27 +1584,27 @@ Methods: FunctionConstant :: struct { using _: NS.Copying(FunctionConstant) } @(objc_type=FunctionConstant, objc_class_name="alloc") -FunctionConstant_alloc :: proc() -> ^FunctionConstant { +FunctionConstant_alloc :: #force_inline proc() -> ^FunctionConstant { return msgSend(^FunctionConstant, FunctionConstant, "alloc") } @(objc_type=FunctionConstant, objc_name="init") -FunctionConstant_init :: proc(self: ^FunctionConstant) -> ^FunctionConstant { +FunctionConstant_init :: #force_inline proc(self: ^FunctionConstant) -> ^FunctionConstant { return msgSend(^FunctionConstant, self, "init") } @(objc_type=FunctionConstant, objc_name="index") -FunctionConstant_index :: proc(self: ^FunctionConstant) -> NS.Integer { +FunctionConstant_index :: #force_inline proc(self: ^FunctionConstant) -> NS.Integer { return msgSend(NS.Integer, self, "index") } @(objc_type=FunctionConstant, objc_name="name") -FunctionConstant_name :: proc(self: ^FunctionConstant) -> ^NS.String { +FunctionConstant_name :: #force_inline proc(self: ^FunctionConstant) -> ^NS.String { return msgSend(^NS.String, self, "name") } @(objc_type=FunctionConstant, objc_name="required") -FunctionConstant_required :: proc(self: ^FunctionConstant) -> BOOL { +FunctionConstant_required :: #force_inline proc(self: ^FunctionConstant) -> BOOL { return msgSend(BOOL, self, "required") } @(objc_type=FunctionConstant, objc_name="type") -FunctionConstant_type :: proc(self: ^FunctionConstant) -> DataType { +FunctionConstant_type :: #force_inline proc(self: ^FunctionConstant) -> DataType { return msgSend(DataType, self, "type") } @@ -1640,27 +1626,27 @@ Methods: FunctionConstantValues :: struct { using _: NS.Copying(FunctionConstantValues) } @(objc_type=FunctionConstantValues, objc_class_name="alloc") -FunctionConstantValues_alloc :: proc() -> ^FunctionConstantValues { +FunctionConstantValues_alloc :: #force_inline proc() -> ^FunctionConstantValues { return msgSend(^FunctionConstantValues, FunctionConstantValues, "alloc") } @(objc_type=FunctionConstantValues, objc_name="init") -FunctionConstantValues_init :: proc(self: ^FunctionConstantValues) -> ^FunctionConstantValues { +FunctionConstantValues_init :: #force_inline proc(self: ^FunctionConstantValues) -> ^FunctionConstantValues { return msgSend(^FunctionConstantValues, self, "init") } @(objc_type=FunctionConstantValues, objc_name="reset") -FunctionConstantValues_reset :: proc(self: ^FunctionConstantValues) { +FunctionConstantValues_reset :: #force_inline proc(self: ^FunctionConstantValues) { msgSend(nil, self, "reset") } @(objc_type=FunctionConstantValues, objc_name="setConstantValue_type_atIndex_") -FunctionConstantValues_setConstantValue_type_atIndex_ :: proc(self: ^FunctionConstantValues, value: rawptr, type: DataType, index: ^NS.Object) { +FunctionConstantValues_setConstantValue_type_atIndex_ :: #force_inline proc(self: ^FunctionConstantValues, value: rawptr, type: DataType, index: ^NS.Object) { msgSend(nil, self, "setConstantValue:type:atIndex:", value, type, index) } @(objc_type=FunctionConstantValues, objc_name="setConstantValue_type_withName_") -FunctionConstantValues_setConstantValue_type_withName_ :: proc(self: ^FunctionConstantValues, value: rawptr, type: DataType, name: ^NS.String) { +FunctionConstantValues_setConstantValue_type_withName_ :: #force_inline proc(self: ^FunctionConstantValues, value: rawptr, type: DataType, name: ^NS.String) { msgSend(nil, self, "setConstantValue:type:withName:", value, type, name) } @(objc_type=FunctionConstantValues, objc_name="setConstantValues") -FunctionConstantValues_setConstantValues :: proc(self: ^FunctionConstantValues, values: rawptr, type: DataType, range: NS.Range) { +FunctionConstantValues_setConstantValues :: #force_inline proc(self: ^FunctionConstantValues, values: rawptr, type: DataType, range: NS.Range) { msgSend(nil, self, "setConstantValues:type:withRange:", values, type, range) } @@ -1687,47 +1673,47 @@ Methods: FunctionDescriptor :: struct { using _: NS.Copying(FunctionDescriptor) } @(objc_type=FunctionDescriptor, objc_class_name="alloc") -FunctionDescriptor_alloc :: proc() -> ^FunctionDescriptor { +FunctionDescriptor_alloc :: #force_inline proc() -> ^FunctionDescriptor { return msgSend(^FunctionDescriptor, FunctionDescriptor, "alloc") } @(objc_type=FunctionDescriptor, objc_name="init") -FunctionDescriptor_init :: proc(self: ^FunctionDescriptor) -> ^FunctionDescriptor { +FunctionDescriptor_init :: #force_inline proc(self: ^FunctionDescriptor) -> ^FunctionDescriptor { return msgSend(^FunctionDescriptor, self, "init") } @(objc_type=FunctionDescriptor, objc_name="constantValues") -FunctionDescriptor_constantValues :: proc(self: ^FunctionDescriptor) -> ^FunctionConstantValues { +FunctionDescriptor_constantValues :: #force_inline proc(self: ^FunctionDescriptor) -> ^FunctionConstantValues { return msgSend(^FunctionConstantValues, self, "constantValues") } @(objc_type=FunctionDescriptor, objc_class_name="functionDescriptor") -FunctionDescriptor_functionDescriptor :: proc() -> ^FunctionDescriptor { +FunctionDescriptor_functionDescriptor :: #force_inline proc() -> ^FunctionDescriptor { return msgSend(^FunctionDescriptor, FunctionDescriptor, "functionDescriptor") } @(objc_type=FunctionDescriptor, objc_name="name") -FunctionDescriptor_name :: proc(self: ^FunctionDescriptor) -> ^NS.String { +FunctionDescriptor_name :: #force_inline proc(self: ^FunctionDescriptor) -> ^NS.String { return msgSend(^NS.String, self, "name") } @(objc_type=FunctionDescriptor, objc_name="options") -FunctionDescriptor_options :: proc(self: ^FunctionDescriptor) -> FunctionOptions { +FunctionDescriptor_options :: #force_inline proc(self: ^FunctionDescriptor) -> FunctionOptions { return msgSend(FunctionOptions, self, "options") } @(objc_type=FunctionDescriptor, objc_name="setConstantValues") -FunctionDescriptor_setConstantValues :: proc(self: ^FunctionDescriptor, constantValues: ^FunctionConstantValues) { +FunctionDescriptor_setConstantValues :: #force_inline proc(self: ^FunctionDescriptor, constantValues: ^FunctionConstantValues) { msgSend(nil, self, "setConstantValues:", constantValues) } @(objc_type=FunctionDescriptor, objc_name="setName") -FunctionDescriptor_setName :: proc(self: ^FunctionDescriptor, name: ^NS.String) { +FunctionDescriptor_setName :: #force_inline proc(self: ^FunctionDescriptor, name: ^NS.String) { msgSend(nil, self, "setName:", name) } @(objc_type=FunctionDescriptor, objc_name="setOptions") -FunctionDescriptor_setOptions :: proc(self: ^FunctionDescriptor, options: FunctionOptions) { +FunctionDescriptor_setOptions :: #force_inline proc(self: ^FunctionDescriptor, options: FunctionOptions) { msgSend(nil, self, "setOptions:", options) } @(objc_type=FunctionDescriptor, objc_name="setSpecializedName") -FunctionDescriptor_setSpecializedName :: proc(self: ^FunctionDescriptor, specializedName: ^NS.String) { +FunctionDescriptor_setSpecializedName :: #force_inline proc(self: ^FunctionDescriptor, specializedName: ^NS.String) { msgSend(nil, self, "setSpecializedName:", specializedName) } @(objc_type=FunctionDescriptor, objc_name="specializedName") -FunctionDescriptor_specializedName :: proc(self: ^FunctionDescriptor) -> ^NS.String { +FunctionDescriptor_specializedName :: #force_inline proc(self: ^FunctionDescriptor) -> ^NS.String { return msgSend(^NS.String, self, "specializedName") } @@ -1745,11 +1731,11 @@ Methods: IntersectionFunctionDescriptor :: struct { using _: NS.Copying(IntersectionFunctionDescriptor) } @(objc_type=IntersectionFunctionDescriptor, objc_class_name="alloc") -IntersectionFunctionDescriptor_alloc :: proc() -> ^IntersectionFunctionDescriptor { +IntersectionFunctionDescriptor_alloc :: #force_inline proc() -> ^IntersectionFunctionDescriptor { return msgSend(^IntersectionFunctionDescriptor, IntersectionFunctionDescriptor, "alloc") } @(objc_type=IntersectionFunctionDescriptor, objc_name="init") -IntersectionFunctionDescriptor_init :: proc(self: ^IntersectionFunctionDescriptor) -> ^IntersectionFunctionDescriptor { +IntersectionFunctionDescriptor_init :: #force_inline proc(self: ^IntersectionFunctionDescriptor) -> ^IntersectionFunctionDescriptor { return msgSend(^IntersectionFunctionDescriptor, self, "init") } @@ -1779,59 +1765,59 @@ Methods: HeapDescriptor :: struct { using _: NS.Copying(HeapDescriptor) } @(objc_type=HeapDescriptor, objc_class_name="alloc") -HeapDescriptor_alloc :: proc() -> ^HeapDescriptor { +HeapDescriptor_alloc :: #force_inline proc() -> ^HeapDescriptor { return msgSend(^HeapDescriptor, HeapDescriptor, "alloc") } @(objc_type=HeapDescriptor, objc_name="init") -HeapDescriptor_init :: proc(self: ^HeapDescriptor) -> ^HeapDescriptor { +HeapDescriptor_init :: #force_inline proc(self: ^HeapDescriptor) -> ^HeapDescriptor { return msgSend(^HeapDescriptor, self, "init") } @(objc_type=HeapDescriptor, objc_name="cpuCacheMode") -HeapDescriptor_cpuCacheMode :: proc(self: ^HeapDescriptor) -> CPUCacheMode { +HeapDescriptor_cpuCacheMode :: #force_inline proc(self: ^HeapDescriptor) -> CPUCacheMode { return msgSend(CPUCacheMode, self, "cpuCacheMode") } @(objc_type=HeapDescriptor, objc_name="hazardTrackingMode") -HeapDescriptor_hazardTrackingMode :: proc(self: ^HeapDescriptor) -> HazardTrackingMode { +HeapDescriptor_hazardTrackingMode :: #force_inline proc(self: ^HeapDescriptor) -> HazardTrackingMode { return msgSend(HazardTrackingMode, self, "hazardTrackingMode") } @(objc_type=HeapDescriptor, objc_name="resourceOptions") -HeapDescriptor_resourceOptions :: proc(self: ^HeapDescriptor) -> ResourceOptions { +HeapDescriptor_resourceOptions :: #force_inline proc(self: ^HeapDescriptor) -> ResourceOptions { return msgSend(ResourceOptions, self, "resourceOptions") } @(objc_type=HeapDescriptor, objc_name="setCpuCacheMode") -HeapDescriptor_setCpuCacheMode :: proc(self: ^HeapDescriptor, cpuCacheMode: CPUCacheMode) { +HeapDescriptor_setCpuCacheMode :: #force_inline proc(self: ^HeapDescriptor, cpuCacheMode: CPUCacheMode) { msgSend(nil, self, "setCpuCacheMode:", cpuCacheMode) } @(objc_type=HeapDescriptor, objc_name="setHazardTrackingMode") -HeapDescriptor_setHazardTrackingMode :: proc(self: ^HeapDescriptor, hazardTrackingMode: HazardTrackingMode) { +HeapDescriptor_setHazardTrackingMode :: #force_inline proc(self: ^HeapDescriptor, hazardTrackingMode: HazardTrackingMode) { msgSend(nil, self, "setHazardTrackingMode:", hazardTrackingMode) } @(objc_type=HeapDescriptor, objc_name="setResourceOptions") -HeapDescriptor_setResourceOptions :: proc(self: ^HeapDescriptor, resourceOptions: ResourceOptions) { +HeapDescriptor_setResourceOptions :: #force_inline proc(self: ^HeapDescriptor, resourceOptions: ResourceOptions) { msgSend(nil, self, "setResourceOptions:", resourceOptions) } @(objc_type=HeapDescriptor, objc_name="setSize") -HeapDescriptor_setSize :: proc(self: ^HeapDescriptor, size: NS.Integer) { +HeapDescriptor_setSize :: #force_inline proc(self: ^HeapDescriptor, size: NS.Integer) { msgSend(nil, self, "setSize:", size) } @(objc_type=HeapDescriptor, objc_name="setStorageMode") -HeapDescriptor_setStorageMode :: proc(self: ^HeapDescriptor, storageMode: StorageMode) { +HeapDescriptor_setStorageMode :: #force_inline proc(self: ^HeapDescriptor, storageMode: StorageMode) { msgSend(nil, self, "setStorageMode:", storageMode) } @(objc_type=HeapDescriptor, objc_name="setType") -HeapDescriptor_setType :: proc(self: ^HeapDescriptor, type: HeapType) { +HeapDescriptor_setType :: #force_inline proc(self: ^HeapDescriptor, type: HeapType) { msgSend(nil, self, "setType:", type) } @(objc_type=HeapDescriptor, objc_name="size") -HeapDescriptor_size :: proc(self: ^HeapDescriptor) -> NS.Integer { +HeapDescriptor_size :: #force_inline proc(self: ^HeapDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "size") } @(objc_type=HeapDescriptor, objc_name="storageMode") -HeapDescriptor_storageMode :: proc(self: ^HeapDescriptor) -> StorageMode { +HeapDescriptor_storageMode :: #force_inline proc(self: ^HeapDescriptor) -> StorageMode { return msgSend(StorageMode, self, "storageMode") } @(objc_type=HeapDescriptor, objc_name="type") -HeapDescriptor_type :: proc(self: ^HeapDescriptor) -> HeapType { +HeapDescriptor_type :: #force_inline proc(self: ^HeapDescriptor) -> HeapType { return msgSend(HeapType, self, "type") } @@ -1861,59 +1847,59 @@ Methods: IndirectCommandBufferDescriptor :: struct { using _: NS.Copying(IndirectCommandBufferDescriptor) } @(objc_type=IndirectCommandBufferDescriptor, objc_class_name="alloc") -IndirectCommandBufferDescriptor_alloc :: proc() -> ^IndirectCommandBufferDescriptor { +IndirectCommandBufferDescriptor_alloc :: #force_inline proc() -> ^IndirectCommandBufferDescriptor { return msgSend(^IndirectCommandBufferDescriptor, IndirectCommandBufferDescriptor, "alloc") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="init") -IndirectCommandBufferDescriptor_init :: proc(self: ^IndirectCommandBufferDescriptor) -> ^IndirectCommandBufferDescriptor { +IndirectCommandBufferDescriptor_init :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> ^IndirectCommandBufferDescriptor { return msgSend(^IndirectCommandBufferDescriptor, self, "init") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="commandTypes") -IndirectCommandBufferDescriptor_commandTypes :: proc(self: ^IndirectCommandBufferDescriptor) -> IndirectCommandType { +IndirectCommandBufferDescriptor_commandTypes :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> IndirectCommandType { return msgSend(IndirectCommandType, self, "commandTypes") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="inheritBuffers") -IndirectCommandBufferDescriptor_inheritBuffers :: proc(self: ^IndirectCommandBufferDescriptor) -> BOOL { +IndirectCommandBufferDescriptor_inheritBuffers :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> BOOL { return msgSend(BOOL, self, "inheritBuffers") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="inheritPipelineState") -IndirectCommandBufferDescriptor_inheritPipelineState :: proc(self: ^IndirectCommandBufferDescriptor) -> BOOL { +IndirectCommandBufferDescriptor_inheritPipelineState :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> BOOL { return msgSend(BOOL, self, "inheritPipelineState") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="maxFragmentBufferBindCount") -IndirectCommandBufferDescriptor_maxFragmentBufferBindCount :: proc(self: ^IndirectCommandBufferDescriptor) -> NS.Integer { +IndirectCommandBufferDescriptor_maxFragmentBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "maxFragmentBufferBindCount") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="maxKernelBufferBindCount") -IndirectCommandBufferDescriptor_maxKernelBufferBindCount :: proc(self: ^IndirectCommandBufferDescriptor) -> NS.Integer { +IndirectCommandBufferDescriptor_maxKernelBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "maxKernelBufferBindCount") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="maxVertexBufferBindCount") -IndirectCommandBufferDescriptor_maxVertexBufferBindCount :: proc(self: ^IndirectCommandBufferDescriptor) -> NS.Integer { +IndirectCommandBufferDescriptor_maxVertexBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "maxVertexBufferBindCount") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="setCommandTypes") -IndirectCommandBufferDescriptor_setCommandTypes :: proc(self: ^IndirectCommandBufferDescriptor, commandTypes: IndirectCommandType) { +IndirectCommandBufferDescriptor_setCommandTypes :: #force_inline proc(self: ^IndirectCommandBufferDescriptor, commandTypes: IndirectCommandType) { msgSend(nil, self, "setCommandTypes:", commandTypes) } @(objc_type=IndirectCommandBufferDescriptor, objc_name="setInheritBuffers") -IndirectCommandBufferDescriptor_setInheritBuffers :: proc(self: ^IndirectCommandBufferDescriptor, inheritBuffers: BOOL) { +IndirectCommandBufferDescriptor_setInheritBuffers :: #force_inline proc(self: ^IndirectCommandBufferDescriptor, inheritBuffers: BOOL) { msgSend(nil, self, "setInheritBuffers:", inheritBuffers) } @(objc_type=IndirectCommandBufferDescriptor, objc_name="setInheritPipelineState") -IndirectCommandBufferDescriptor_setInheritPipelineState :: proc(self: ^IndirectCommandBufferDescriptor, inheritPipelineState: BOOL) { +IndirectCommandBufferDescriptor_setInheritPipelineState :: #force_inline proc(self: ^IndirectCommandBufferDescriptor, inheritPipelineState: BOOL) { msgSend(nil, self, "setInheritPipelineState:", inheritPipelineState) } @(objc_type=IndirectCommandBufferDescriptor, objc_name="setMaxFragmentBufferBindCount") -IndirectCommandBufferDescriptor_setMaxFragmentBufferBindCount :: proc(self: ^IndirectCommandBufferDescriptor, maxFragmentBufferBindCount: NS.Integer) { +IndirectCommandBufferDescriptor_setMaxFragmentBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor, maxFragmentBufferBindCount: NS.Integer) { msgSend(nil, self, "setMaxFragmentBufferBindCount:", maxFragmentBufferBindCount) } @(objc_type=IndirectCommandBufferDescriptor, objc_name="setMaxKernelBufferBindCount") -IndirectCommandBufferDescriptor_setMaxKernelBufferBindCount :: proc(self: ^IndirectCommandBufferDescriptor, maxKernelBufferBindCount: NS.Integer) { +IndirectCommandBufferDescriptor_setMaxKernelBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor, maxKernelBufferBindCount: NS.Integer) { msgSend(nil, self, "setMaxKernelBufferBindCount:", maxKernelBufferBindCount) } @(objc_type=IndirectCommandBufferDescriptor, objc_name="setMaxVertexBufferBindCount") -IndirectCommandBufferDescriptor_setMaxVertexBufferBindCount :: proc(self: ^IndirectCommandBufferDescriptor, maxVertexBufferBindCount: NS.Integer) { +IndirectCommandBufferDescriptor_setMaxVertexBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor, maxVertexBufferBindCount: NS.Integer) { msgSend(nil, self, "setMaxVertexBufferBindCount:", maxVertexBufferBindCount) } @@ -1942,55 +1928,55 @@ Methods: InstanceAccelerationStructureDescriptor :: struct { using _: NS.Copying(InstanceAccelerationStructureDescriptor) } @(objc_type=InstanceAccelerationStructureDescriptor, objc_class_name="alloc") -InstanceAccelerationStructureDescriptor_alloc :: proc() -> ^InstanceAccelerationStructureDescriptor { +InstanceAccelerationStructureDescriptor_alloc :: #force_inline proc() -> ^InstanceAccelerationStructureDescriptor { return msgSend(^InstanceAccelerationStructureDescriptor, InstanceAccelerationStructureDescriptor, "alloc") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="init") -InstanceAccelerationStructureDescriptor_init :: proc(self: ^InstanceAccelerationStructureDescriptor) -> ^InstanceAccelerationStructureDescriptor { +InstanceAccelerationStructureDescriptor_init :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> ^InstanceAccelerationStructureDescriptor { return msgSend(^InstanceAccelerationStructureDescriptor, self, "init") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_class_name="descriptor") -InstanceAccelerationStructureDescriptor_descriptor :: proc() -> ^InstanceAccelerationStructureDescriptor { +InstanceAccelerationStructureDescriptor_descriptor :: #force_inline proc() -> ^InstanceAccelerationStructureDescriptor { return msgSend(^InstanceAccelerationStructureDescriptor, InstanceAccelerationStructureDescriptor, "descriptor") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceCount") -InstanceAccelerationStructureDescriptor_instanceCount :: proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.Integer { +InstanceAccelerationStructureDescriptor_instanceCount :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "instanceCount") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceDescriptorBuffer") -InstanceAccelerationStructureDescriptor_instanceDescriptorBuffer :: proc(self: ^InstanceAccelerationStructureDescriptor) -> ^InstanceAccelerationStructureDescriptor { +InstanceAccelerationStructureDescriptor_instanceDescriptorBuffer :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> ^InstanceAccelerationStructureDescriptor { return msgSend(^InstanceAccelerationStructureDescriptor, self, "instanceDescriptorBuffer") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceDescriptorBufferOffset") -InstanceAccelerationStructureDescriptor_instanceDescriptorBufferOffset :: proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.Integer { +InstanceAccelerationStructureDescriptor_instanceDescriptorBufferOffset :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "instanceDescriptorBufferOffset") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceDescriptorStride") -InstanceAccelerationStructureDescriptor_instanceDescriptorStride :: proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.Integer { +InstanceAccelerationStructureDescriptor_instanceDescriptorStride :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "instanceDescriptorStride") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instancedAccelerationStructures") -InstanceAccelerationStructureDescriptor_instancedAccelerationStructures :: proc(self: ^InstanceAccelerationStructureDescriptor) -> ^NS.Array { +InstanceAccelerationStructureDescriptor_instancedAccelerationStructures :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> ^NS.Array { return msgSend(^NS.Array, self, "instancedAccelerationStructures") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceCount") -InstanceAccelerationStructureDescriptor_setInstanceCount :: proc(self: ^InstanceAccelerationStructureDescriptor, instanceCount: NS.Integer) { +InstanceAccelerationStructureDescriptor_setInstanceCount :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, instanceCount: NS.Integer) { msgSend(nil, self, "setInstanceCount:", instanceCount) } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceDescriptorBuffer") -InstanceAccelerationStructureDescriptor_setInstanceDescriptorBuffer :: proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorBuffer: ^NS.Object) { +InstanceAccelerationStructureDescriptor_setInstanceDescriptorBuffer :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorBuffer: ^NS.Object) { msgSend(nil, self, "setInstanceDescriptorBuffer:", instanceDescriptorBuffer) } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceDescriptorBufferOffset") -InstanceAccelerationStructureDescriptor_setInstanceDescriptorBufferOffset :: proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorBufferOffset: NS.Integer) { +InstanceAccelerationStructureDescriptor_setInstanceDescriptorBufferOffset :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorBufferOffset: NS.Integer) { msgSend(nil, self, "setInstanceDescriptorBufferOffset:", instanceDescriptorBufferOffset) } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceDescriptorStride") -InstanceAccelerationStructureDescriptor_setInstanceDescriptorStride :: proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorStride: NS.Integer) { +InstanceAccelerationStructureDescriptor_setInstanceDescriptorStride :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorStride: NS.Integer) { msgSend(nil, self, "setInstanceDescriptorStride:", instanceDescriptorStride) } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstancedAccelerationStructures") -InstanceAccelerationStructureDescriptor_setInstancedAccelerationStructures :: proc(self: ^InstanceAccelerationStructureDescriptor, instancedAccelerationStructures: ^NS.Array) { +InstanceAccelerationStructureDescriptor_setInstancedAccelerationStructures :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, instancedAccelerationStructures: ^NS.Array) { msgSend(nil, self, "setInstancedAccelerationStructures:", instancedAccelerationStructures) } @@ -2011,23 +1997,23 @@ Methods: IntersectionFunctionTableDescriptor :: struct { using _: NS.Copying(IntersectionFunctionTableDescriptor) } @(objc_type=IntersectionFunctionTableDescriptor, objc_class_name="alloc") -IntersectionFunctionTableDescriptor_alloc :: proc() -> ^IntersectionFunctionTableDescriptor { +IntersectionFunctionTableDescriptor_alloc :: #force_inline proc() -> ^IntersectionFunctionTableDescriptor { return msgSend(^IntersectionFunctionTableDescriptor, IntersectionFunctionTableDescriptor, "alloc") } @(objc_type=IntersectionFunctionTableDescriptor, objc_name="init") -IntersectionFunctionTableDescriptor_init :: proc(self: ^IntersectionFunctionTableDescriptor) -> ^IntersectionFunctionTableDescriptor { +IntersectionFunctionTableDescriptor_init :: #force_inline proc(self: ^IntersectionFunctionTableDescriptor) -> ^IntersectionFunctionTableDescriptor { return msgSend(^IntersectionFunctionTableDescriptor, self, "init") } @(objc_type=IntersectionFunctionTableDescriptor, objc_name="functionCount") -IntersectionFunctionTableDescriptor_functionCount :: proc(self: ^IntersectionFunctionTableDescriptor) -> NS.Integer { +IntersectionFunctionTableDescriptor_functionCount :: #force_inline proc(self: ^IntersectionFunctionTableDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "functionCount") } @(objc_type=IntersectionFunctionTableDescriptor, objc_class_name="intersectionFunctionTableDescriptor") -IntersectionFunctionTableDescriptor_intersectionFunctionTableDescriptor :: proc() -> ^IntersectionFunctionTableDescriptor { +IntersectionFunctionTableDescriptor_intersectionFunctionTableDescriptor :: #force_inline proc() -> ^IntersectionFunctionTableDescriptor { return msgSend(^IntersectionFunctionTableDescriptor, IntersectionFunctionTableDescriptor, "intersectionFunctionTableDescriptor") } @(objc_type=IntersectionFunctionTableDescriptor, objc_name="setFunctionCount") -IntersectionFunctionTableDescriptor_setFunctionCount :: proc(self: ^IntersectionFunctionTableDescriptor, functionCount: NS.Integer) { +IntersectionFunctionTableDescriptor_setFunctionCount :: #force_inline proc(self: ^IntersectionFunctionTableDescriptor, functionCount: NS.Integer) { msgSend(nil, self, "setFunctionCount:", functionCount) } @@ -2052,39 +2038,39 @@ Methods: LinkedFunctions :: struct { using _: NS.Copying(LinkedFunctions) } @(objc_type=LinkedFunctions, objc_class_name="alloc") -LinkedFunctions_alloc :: proc() -> ^LinkedFunctions { +LinkedFunctions_alloc :: #force_inline proc() -> ^LinkedFunctions { return msgSend(^LinkedFunctions, LinkedFunctions, "alloc") } @(objc_type=LinkedFunctions, objc_name="init") -LinkedFunctions_init :: proc(self: ^LinkedFunctions) -> ^LinkedFunctions { +LinkedFunctions_init :: #force_inline proc(self: ^LinkedFunctions) -> ^LinkedFunctions { return msgSend(^LinkedFunctions, self, "init") } @(objc_type=LinkedFunctions, objc_name="binaryFunctions") -LinkedFunctions_binaryFunctions :: proc(self: ^LinkedFunctions) -> ^NS.Array { +LinkedFunctions_binaryFunctions :: #force_inline proc(self: ^LinkedFunctions) -> ^NS.Array { return msgSend(^NS.Array, self, "binaryFunctions") } @(objc_type=LinkedFunctions, objc_name="functions") -LinkedFunctions_functions :: proc(self: ^LinkedFunctions) -> ^NS.Array { +LinkedFunctions_functions :: #force_inline proc(self: ^LinkedFunctions) -> ^NS.Array { return msgSend(^NS.Array, self, "functions") } @(objc_type=LinkedFunctions, objc_name="groups") -LinkedFunctions_groups :: proc(self: ^LinkedFunctions) -> ^NS.Dictionary { +LinkedFunctions_groups :: #force_inline proc(self: ^LinkedFunctions) -> ^NS.Dictionary { return msgSend(^NS.Dictionary, self, "groups") } @(objc_type=LinkedFunctions, objc_class_name="linkedFunctions") -LinkedFunctions_linkedFunctions :: proc() -> ^LinkedFunctions { +LinkedFunctions_linkedFunctions :: #force_inline proc() -> ^LinkedFunctions { return msgSend(^LinkedFunctions, LinkedFunctions, "linkedFunctions") } @(objc_type=LinkedFunctions, objc_name="setBinaryFunctions") -LinkedFunctions_setBinaryFunctions :: proc(self: ^LinkedFunctions, binaryFunctions: ^NS.Array) { +LinkedFunctions_setBinaryFunctions :: #force_inline proc(self: ^LinkedFunctions, binaryFunctions: ^NS.Array) { msgSend(nil, self, "setBinaryFunctions:", binaryFunctions) } @(objc_type=LinkedFunctions, objc_name="setFunctions") -LinkedFunctions_setFunctions :: proc(self: ^LinkedFunctions, functions: ^NS.Array) { +LinkedFunctions_setFunctions :: #force_inline proc(self: ^LinkedFunctions, functions: ^NS.Array) { msgSend(nil, self, "setFunctions:", functions) } @(objc_type=LinkedFunctions, objc_name="setGroups") -LinkedFunctions_setGroups :: proc(self: ^LinkedFunctions, groups: ^NS.Dictionary) { +LinkedFunctions_setGroups :: #force_inline proc(self: ^LinkedFunctions, groups: ^NS.Dictionary) { msgSend(nil, self, "setGroups:", groups) } @@ -2104,19 +2090,19 @@ Methods: PipelineBufferDescriptor :: struct { using _: NS.Copying(PipelineBufferDescriptor) } @(objc_type=PipelineBufferDescriptor, objc_class_name="alloc") -PipelineBufferDescriptor_alloc :: proc() -> ^PipelineBufferDescriptor { +PipelineBufferDescriptor_alloc :: #force_inline proc() -> ^PipelineBufferDescriptor { return msgSend(^PipelineBufferDescriptor, PipelineBufferDescriptor, "alloc") } @(objc_type=PipelineBufferDescriptor, objc_name="init") -PipelineBufferDescriptor_init :: proc(self: ^PipelineBufferDescriptor) -> ^PipelineBufferDescriptor { +PipelineBufferDescriptor_init :: #force_inline proc(self: ^PipelineBufferDescriptor) -> ^PipelineBufferDescriptor { return msgSend(^PipelineBufferDescriptor, self, "init") } @(objc_type=PipelineBufferDescriptor, objc_name="mutability") -PipelineBufferDescriptor_mutability :: proc(self: ^PipelineBufferDescriptor) -> Mutability { +PipelineBufferDescriptor_mutability :: #force_inline proc(self: ^PipelineBufferDescriptor) -> Mutability { return msgSend(Mutability, self, "mutability") } @(objc_type=PipelineBufferDescriptor, objc_name="setMutability") -PipelineBufferDescriptor_setMutability :: proc(self: ^PipelineBufferDescriptor, mutability: Mutability) { +PipelineBufferDescriptor_setMutability :: #force_inline proc(self: ^PipelineBufferDescriptor, mutability: Mutability) { msgSend(nil, self, "setMutability:", mutability) } @@ -2136,19 +2122,19 @@ Methods: PipelineBufferDescriptorArray :: struct { using _: NS.Object } @(objc_type=PipelineBufferDescriptorArray, objc_class_name="alloc") -PipelineBufferDescriptorArray_alloc :: proc() -> ^PipelineBufferDescriptorArray { +PipelineBufferDescriptorArray_alloc :: #force_inline proc() -> ^PipelineBufferDescriptorArray { return msgSend(^PipelineBufferDescriptorArray, PipelineBufferDescriptorArray, "alloc") } @(objc_type=PipelineBufferDescriptorArray, objc_name="init") -PipelineBufferDescriptorArray_init :: proc(self: ^PipelineBufferDescriptorArray) -> ^PipelineBufferDescriptorArray { +PipelineBufferDescriptorArray_init :: #force_inline proc(self: ^PipelineBufferDescriptorArray) -> ^PipelineBufferDescriptorArray { return msgSend(^PipelineBufferDescriptorArray, self, "init") } @(objc_type=PipelineBufferDescriptorArray, objc_name="objectAtIndexedSubscript") -PipelineBufferDescriptorArray_objectAtIndexedSubscript :: proc(self: ^PipelineBufferDescriptorArray, bufferIndex: ^NS.Object) -> ^PipelineBufferDescriptor { +PipelineBufferDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^PipelineBufferDescriptorArray, bufferIndex: ^NS.Object) -> ^PipelineBufferDescriptor { return msgSend(^PipelineBufferDescriptor, self, "objectAtIndexedSubscript:", bufferIndex) } @(objc_type=PipelineBufferDescriptorArray, objc_name="setObject") -PipelineBufferDescriptorArray_setObject :: proc(self: ^PipelineBufferDescriptorArray, buffer: ^PipelineBufferDescriptor, bufferIndex: ^NS.Object) { +PipelineBufferDescriptorArray_setObject :: #force_inline proc(self: ^PipelineBufferDescriptorArray, buffer: ^PipelineBufferDescriptor, bufferIndex: ^NS.Object) { msgSend(nil, self, "setObject:atIndexedSubscript:", buffer, bufferIndex) } @@ -2173,39 +2159,39 @@ Methods: PointerType :: struct { using _: NS.Object } @(objc_type=PointerType, objc_class_name="alloc") -PointerType_alloc :: proc() -> ^PointerType { +PointerType_alloc :: #force_inline proc() -> ^PointerType { return msgSend(^PointerType, PointerType, "alloc") } @(objc_type=PointerType, objc_name="init") -PointerType_init :: proc(self: ^PointerType) -> ^PointerType { +PointerType_init :: #force_inline proc(self: ^PointerType) -> ^PointerType { return msgSend(^PointerType, self, "init") } @(objc_type=PointerType, objc_name="access") -PointerType_access :: proc(self: ^PointerType) -> ArgumentAccess { +PointerType_access :: #force_inline proc(self: ^PointerType) -> ArgumentAccess { return msgSend(ArgumentAccess, self, "access") } @(objc_type=PointerType, objc_name="alignment") -PointerType_alignment :: proc(self: ^PointerType) -> NS.Integer { +PointerType_alignment :: #force_inline proc(self: ^PointerType) -> NS.Integer { return msgSend(NS.Integer, self, "alignment") } @(objc_type=PointerType, objc_name="dataSize") -PointerType_dataSize :: proc(self: ^PointerType) -> NS.Integer { +PointerType_dataSize :: #force_inline proc(self: ^PointerType) -> NS.Integer { return msgSend(NS.Integer, self, "dataSize") } @(objc_type=PointerType, objc_name="elementArrayType") -PointerType_elementArrayType :: proc(self: ^PointerType) -> ^ArrayType { +PointerType_elementArrayType :: #force_inline proc(self: ^PointerType) -> ^ArrayType { return msgSend(^ArrayType, self, "elementArrayType") } @(objc_type=PointerType, objc_name="elementIsArgumentBuffer") -PointerType_elementIsArgumentBuffer :: proc(self: ^PointerType) -> BOOL { +PointerType_elementIsArgumentBuffer :: #force_inline proc(self: ^PointerType) -> BOOL { return msgSend(BOOL, self, "elementIsArgumentBuffer") } @(objc_type=PointerType, objc_name="elementStructType") -PointerType_elementStructType :: proc(self: ^PointerType) -> ^StructType { +PointerType_elementStructType :: #force_inline proc(self: ^PointerType) -> ^StructType { return msgSend(^StructType, self, "elementStructType") } @(objc_type=PointerType, objc_name="elementType") -PointerType_elementType :: proc(self: ^PointerType) -> DataType { +PointerType_elementType :: #force_inline proc(self: ^PointerType) -> DataType { return msgSend(DataType, self, "elementType") } @@ -2226,23 +2212,23 @@ Methods: PrimitiveAccelerationStructureDescriptor :: struct { using _: NS.Copying(PrimitiveAccelerationStructureDescriptor) } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_class_name="alloc") -PrimitiveAccelerationStructureDescriptor_alloc :: proc() -> ^PrimitiveAccelerationStructureDescriptor { +PrimitiveAccelerationStructureDescriptor_alloc :: #force_inline proc() -> ^PrimitiveAccelerationStructureDescriptor { return msgSend(^PrimitiveAccelerationStructureDescriptor, PrimitiveAccelerationStructureDescriptor, "alloc") } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="init") -PrimitiveAccelerationStructureDescriptor_init :: proc(self: ^PrimitiveAccelerationStructureDescriptor) -> ^PrimitiveAccelerationStructureDescriptor { +PrimitiveAccelerationStructureDescriptor_init :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor) -> ^PrimitiveAccelerationStructureDescriptor { return msgSend(^PrimitiveAccelerationStructureDescriptor, self, "init") } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_class_name="descriptor") -PrimitiveAccelerationStructureDescriptor_descriptor :: proc() -> ^PrimitiveAccelerationStructureDescriptor { +PrimitiveAccelerationStructureDescriptor_descriptor :: #force_inline proc() -> ^PrimitiveAccelerationStructureDescriptor { return msgSend(^PrimitiveAccelerationStructureDescriptor, PrimitiveAccelerationStructureDescriptor, "descriptor") } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="geometryDescriptors") -PrimitiveAccelerationStructureDescriptor_geometryDescriptors :: proc(self: ^PrimitiveAccelerationStructureDescriptor) -> ^NS.Array { +PrimitiveAccelerationStructureDescriptor_geometryDescriptors :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor) -> ^NS.Array { return msgSend(^NS.Array, self, "geometryDescriptors") } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="setGeometryDescriptors") -PrimitiveAccelerationStructureDescriptor_setGeometryDescriptors :: proc(self: ^PrimitiveAccelerationStructureDescriptor, geometryDescriptors: ^NS.Array) { +PrimitiveAccelerationStructureDescriptor_setGeometryDescriptors :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor, geometryDescriptors: ^NS.Array) { msgSend(nil, self, "setGeometryDescriptors:", geometryDescriptors) } @@ -2262,19 +2248,19 @@ Methods: RasterizationRateLayerArray :: struct { using _: NS.Object } @(objc_type=RasterizationRateLayerArray, objc_class_name="alloc") -RasterizationRateLayerArray_alloc :: proc() -> ^RasterizationRateLayerArray { +RasterizationRateLayerArray_alloc :: #force_inline proc() -> ^RasterizationRateLayerArray { return msgSend(^RasterizationRateLayerArray, RasterizationRateLayerArray, "alloc") } @(objc_type=RasterizationRateLayerArray, objc_name="init") -RasterizationRateLayerArray_init :: proc(self: ^RasterizationRateLayerArray) -> ^RasterizationRateLayerArray { +RasterizationRateLayerArray_init :: #force_inline proc(self: ^RasterizationRateLayerArray) -> ^RasterizationRateLayerArray { return msgSend(^RasterizationRateLayerArray, self, "init") } @(objc_type=RasterizationRateLayerArray, objc_name="objectAtIndexedSubscript") -RasterizationRateLayerArray_objectAtIndexedSubscript :: proc(self: ^RasterizationRateLayerArray, layerIndex: ^NS.Object) -> ^RasterizationRateLayerDescriptor { +RasterizationRateLayerArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RasterizationRateLayerArray, layerIndex: ^NS.Object) -> ^RasterizationRateLayerDescriptor { return msgSend(^RasterizationRateLayerDescriptor, self, "objectAtIndexedSubscript:", layerIndex) } @(objc_type=RasterizationRateLayerArray, objc_name="setObject") -RasterizationRateLayerArray_setObject :: proc(self: ^RasterizationRateLayerArray, layer: ^RasterizationRateLayerDescriptor, layerIndex: ^NS.Object) { +RasterizationRateLayerArray_setObject :: #force_inline proc(self: ^RasterizationRateLayerArray, layer: ^RasterizationRateLayerDescriptor, layerIndex: ^NS.Object) { msgSend(nil, self, "setObject:atIndexedSubscript:", layer, layerIndex) } @@ -2299,39 +2285,39 @@ Methods: RasterizationRateLayerDescriptor :: struct { using _: NS.Copying(RasterizationRateLayerDescriptor) } @(objc_type=RasterizationRateLayerDescriptor, objc_class_name="alloc") -RasterizationRateLayerDescriptor_alloc :: proc() -> ^RasterizationRateLayerDescriptor { +RasterizationRateLayerDescriptor_alloc :: #force_inline proc() -> ^RasterizationRateLayerDescriptor { return msgSend(^RasterizationRateLayerDescriptor, RasterizationRateLayerDescriptor, "alloc") } @(objc_type=RasterizationRateLayerDescriptor, objc_name="horizontal") -RasterizationRateLayerDescriptor_horizontal :: proc(self: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateSampleArray { +RasterizationRateLayerDescriptor_horizontal :: #force_inline proc(self: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateSampleArray { return msgSend(^RasterizationRateSampleArray, self, "horizontal") } @(objc_type=RasterizationRateLayerDescriptor, objc_name="horizontalSampleStorage") -RasterizationRateLayerDescriptor_horizontalSampleStorage :: proc(self: ^RasterizationRateLayerDescriptor) -> ^f32 { +RasterizationRateLayerDescriptor_horizontalSampleStorage :: #force_inline proc(self: ^RasterizationRateLayerDescriptor) -> ^f32 { return msgSend(^f32, self, "horizontalSampleStorage") } @(objc_type=RasterizationRateLayerDescriptor, objc_name="init") -RasterizationRateLayerDescriptor_init :: proc(self: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateLayerDescriptor { +RasterizationRateLayerDescriptor_init :: #force_inline proc(self: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateLayerDescriptor { return msgSend(^RasterizationRateLayerDescriptor, self, "init") } @(objc_type=RasterizationRateLayerDescriptor, objc_name="initWithSampleCount") -RasterizationRateLayerDescriptor_initWithSampleCount :: proc(self: ^RasterizationRateLayerDescriptor, sampleCount: Size) -> ^RasterizationRateLayerDescriptor { +RasterizationRateLayerDescriptor_initWithSampleCount :: #force_inline proc(self: ^RasterizationRateLayerDescriptor, sampleCount: Size) -> ^RasterizationRateLayerDescriptor { return msgSend(^RasterizationRateLayerDescriptor, self, "initWithSampleCount:", sampleCount) } @(objc_type=RasterizationRateLayerDescriptor, objc_name="initWithSampleCountWithDimensions") -RasterizationRateLayerDescriptor_initWithSampleCountWithDimensions :: proc(self: ^RasterizationRateLayerDescriptor, sampleCount: Size, horizontal: ^f32, vertical: ^f32) -> ^RasterizationRateLayerDescriptor { +RasterizationRateLayerDescriptor_initWithSampleCountWithDimensions :: #force_inline proc(self: ^RasterizationRateLayerDescriptor, sampleCount: Size, horizontal: ^f32, vertical: ^f32) -> ^RasterizationRateLayerDescriptor { return msgSend(^RasterizationRateLayerDescriptor, self, "initWithSampleCount:horizontal:vertical:", sampleCount, horizontal, vertical) } @(objc_type=RasterizationRateLayerDescriptor, objc_name="sampleCount") -RasterizationRateLayerDescriptor_sampleCount :: proc(self: ^RasterizationRateLayerDescriptor) -> Size { +RasterizationRateLayerDescriptor_sampleCount :: #force_inline proc(self: ^RasterizationRateLayerDescriptor) -> Size { return msgSend(Size, self, "sampleCount") } @(objc_type=RasterizationRateLayerDescriptor, objc_name="vertical") -RasterizationRateLayerDescriptor_vertical :: proc(self: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateSampleArray { +RasterizationRateLayerDescriptor_vertical :: #force_inline proc(self: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateSampleArray { return msgSend(^RasterizationRateSampleArray, self, "vertical") } @(objc_type=RasterizationRateLayerDescriptor, objc_name="verticalSampleStorage") -RasterizationRateLayerDescriptor_verticalSampleStorage :: proc(self: ^RasterizationRateLayerDescriptor) -> ^f32 { +RasterizationRateLayerDescriptor_verticalSampleStorage :: #force_inline proc(self: ^RasterizationRateLayerDescriptor) -> ^f32 { return msgSend(^f32, self, "verticalSampleStorage") } @@ -2360,55 +2346,55 @@ Methods: RasterizationRateMapDescriptor :: struct { using _: NS.Copying(RasterizationRateMapDescriptor) } @(objc_type=RasterizationRateMapDescriptor, objc_class_name="alloc") -RasterizationRateMapDescriptor_alloc :: proc() -> ^RasterizationRateMapDescriptor { +RasterizationRateMapDescriptor_alloc :: #force_inline proc() -> ^RasterizationRateMapDescriptor { return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "alloc") } @(objc_type=RasterizationRateMapDescriptor, objc_name="init") -RasterizationRateMapDescriptor_init :: proc(self: ^RasterizationRateMapDescriptor) -> ^RasterizationRateMapDescriptor { +RasterizationRateMapDescriptor_init :: #force_inline proc(self: ^RasterizationRateMapDescriptor) -> ^RasterizationRateMapDescriptor { return msgSend(^RasterizationRateMapDescriptor, self, "init") } @(objc_type=RasterizationRateMapDescriptor, objc_name="label") -RasterizationRateMapDescriptor_label :: proc(self: ^RasterizationRateMapDescriptor) -> ^NS.String { +RasterizationRateMapDescriptor_label :: #force_inline proc(self: ^RasterizationRateMapDescriptor) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=RasterizationRateMapDescriptor, objc_name="layerAtIndex") -RasterizationRateMapDescriptor_layerAtIndex :: proc(self: ^RasterizationRateMapDescriptor, layerIndex: ^NS.Object) -> ^RasterizationRateLayerDescriptor { +RasterizationRateMapDescriptor_layerAtIndex :: #force_inline proc(self: ^RasterizationRateMapDescriptor, layerIndex: ^NS.Object) -> ^RasterizationRateLayerDescriptor { return msgSend(^RasterizationRateLayerDescriptor, self, "layerAtIndex:", layerIndex) } @(objc_type=RasterizationRateMapDescriptor, objc_name="layerCount") -RasterizationRateMapDescriptor_layerCount :: proc(self: ^RasterizationRateMapDescriptor) -> NS.Integer { +RasterizationRateMapDescriptor_layerCount :: #force_inline proc(self: ^RasterizationRateMapDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "layerCount") } @(objc_type=RasterizationRateMapDescriptor, objc_name="layers") -RasterizationRateMapDescriptor_layers :: proc(self: ^RasterizationRateMapDescriptor) -> ^RasterizationRateLayerArray { +RasterizationRateMapDescriptor_layers :: #force_inline proc(self: ^RasterizationRateMapDescriptor) -> ^RasterizationRateLayerArray { return msgSend(^RasterizationRateLayerArray, self, "layers") } @(objc_type=RasterizationRateMapDescriptor, objc_class_name="rasterizationRateMapDescriptorWithScreenSize") -RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize :: proc(screenSize: Size) -> ^RasterizationRateMapDescriptor { +RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize :: #force_inline proc(screenSize: Size) -> ^RasterizationRateMapDescriptor { return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:", screenSize) } @(objc_type=RasterizationRateMapDescriptor, objc_class_name="rasterizationRateMapDescriptorWithScreenSize_layer_") -RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize_layer_ :: proc(screenSize: Size, layer: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateMapDescriptor { +RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize_layer_ :: #force_inline proc(screenSize: Size, layer: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateMapDescriptor { return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:layer:", screenSize, layer) } @(objc_type=RasterizationRateMapDescriptor, objc_class_name="rasterizationRateMapDescriptorWithScreenSize_layerCount_layers_") -RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize_layerCount_layers_ :: proc(screenSize: Size, layerCount: ^NS.Object, layers: ^^RasterizationRateLayerDescriptor ) -> ^RasterizationRateMapDescriptor { +RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize_layerCount_layers_ :: #force_inline proc(screenSize: Size, layerCount: ^NS.Object, layers: ^^RasterizationRateLayerDescriptor ) -> ^RasterizationRateMapDescriptor { return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:layerCount:layers:", screenSize, layerCount, layers) } @(objc_type=RasterizationRateMapDescriptor, objc_name="screenSize") -RasterizationRateMapDescriptor_screenSize :: proc(self: ^RasterizationRateMapDescriptor) -> Size { +RasterizationRateMapDescriptor_screenSize :: #force_inline proc(self: ^RasterizationRateMapDescriptor) -> Size { return msgSend(Size, self, "screenSize") } @(objc_type=RasterizationRateMapDescriptor, objc_name="setLabel") -RasterizationRateMapDescriptor_setLabel :: proc(self: ^RasterizationRateMapDescriptor, label: ^NS.String) { +RasterizationRateMapDescriptor_setLabel :: #force_inline proc(self: ^RasterizationRateMapDescriptor, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=RasterizationRateMapDescriptor, objc_name="setLayer") -RasterizationRateMapDescriptor_setLayer :: proc(self: ^RasterizationRateMapDescriptor, layer: ^RasterizationRateLayerDescriptor, layerIndex: ^NS.Object) { +RasterizationRateMapDescriptor_setLayer :: #force_inline proc(self: ^RasterizationRateMapDescriptor, layer: ^RasterizationRateLayerDescriptor, layerIndex: ^NS.Object) { msgSend(nil, self, "setLayer:atIndex:", layer, layerIndex) } @(objc_type=RasterizationRateMapDescriptor, objc_name="setScreenSize") -RasterizationRateMapDescriptor_setScreenSize :: proc(self: ^RasterizationRateMapDescriptor, screenSize: Size) { +RasterizationRateMapDescriptor_setScreenSize :: #force_inline proc(self: ^RasterizationRateMapDescriptor, screenSize: Size) { msgSend(nil, self, "setScreenSize:", screenSize) } @@ -2428,19 +2414,19 @@ Methods: RasterizationRateSampleArray :: struct { using _: NS.Object } @(objc_type=RasterizationRateSampleArray, objc_class_name="alloc") -RasterizationRateSampleArray_alloc :: proc() -> ^RasterizationRateSampleArray { +RasterizationRateSampleArray_alloc :: #force_inline proc() -> ^RasterizationRateSampleArray { return msgSend(^RasterizationRateSampleArray, RasterizationRateSampleArray, "alloc") } @(objc_type=RasterizationRateSampleArray, objc_name="init") -RasterizationRateSampleArray_init :: proc(self: ^RasterizationRateSampleArray) -> ^RasterizationRateSampleArray { +RasterizationRateSampleArray_init :: #force_inline proc(self: ^RasterizationRateSampleArray) -> ^RasterizationRateSampleArray { return msgSend(^RasterizationRateSampleArray, self, "init") } @(objc_type=RasterizationRateSampleArray, objc_name="objectAtIndexedSubscript") -RasterizationRateSampleArray_objectAtIndexedSubscript :: proc(self: ^RasterizationRateSampleArray, index: ^NS.Object) -> ^NS.Number { +RasterizationRateSampleArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RasterizationRateSampleArray, index: ^NS.Object) -> ^NS.Number { return msgSend(^NS.Number, self, "objectAtIndexedSubscript:", index) } @(objc_type=RasterizationRateSampleArray, objc_name="setObject") -RasterizationRateSampleArray_setObject :: proc(self: ^RasterizationRateSampleArray, value: ^NS.Number, index: ^NS.Object) { +RasterizationRateSampleArray_setObject :: #force_inline proc(self: ^RasterizationRateSampleArray, value: ^NS.Number, index: ^NS.Object) { msgSend(nil, self, "setObject:atIndexedSubscript:", value, index) } @@ -2480,99 +2466,99 @@ Methods: RenderPassAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassAttachmentDescriptor) } @(objc_type=RenderPassAttachmentDescriptor, objc_class_name="alloc") -RenderPassAttachmentDescriptor_alloc :: proc() -> ^RenderPassAttachmentDescriptor { +RenderPassAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPassAttachmentDescriptor { return msgSend(^RenderPassAttachmentDescriptor, RenderPassAttachmentDescriptor, "alloc") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="init") -RenderPassAttachmentDescriptor_init :: proc(self: ^RenderPassAttachmentDescriptor) -> ^RenderPassAttachmentDescriptor { +RenderPassAttachmentDescriptor_init :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> ^RenderPassAttachmentDescriptor { return msgSend(^RenderPassAttachmentDescriptor, self, "init") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="depthPlane") -RenderPassAttachmentDescriptor_depthPlane :: proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { +RenderPassAttachmentDescriptor_depthPlane :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "depthPlane") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="level") -RenderPassAttachmentDescriptor_level :: proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { +RenderPassAttachmentDescriptor_level :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "level") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="loadAction") -RenderPassAttachmentDescriptor_loadAction :: proc(self: ^RenderPassAttachmentDescriptor) -> LoadAction { +RenderPassAttachmentDescriptor_loadAction :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> LoadAction { return msgSend(LoadAction, self, "loadAction") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveDepthPlane") -RenderPassAttachmentDescriptor_resolveDepthPlane :: proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { +RenderPassAttachmentDescriptor_resolveDepthPlane :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "resolveDepthPlane") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveLevel") -RenderPassAttachmentDescriptor_resolveLevel :: proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { +RenderPassAttachmentDescriptor_resolveLevel :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "resolveLevel") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveSlice") -RenderPassAttachmentDescriptor_resolveSlice :: proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { +RenderPassAttachmentDescriptor_resolveSlice :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "resolveSlice") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveTexture") -RenderPassAttachmentDescriptor_resolveTexture :: proc(self: ^RenderPassAttachmentDescriptor) -> ^RenderPassAttachmentDescriptor { +RenderPassAttachmentDescriptor_resolveTexture :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> ^RenderPassAttachmentDescriptor { return msgSend(^RenderPassAttachmentDescriptor, self, "resolveTexture") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setDepthPlane") -RenderPassAttachmentDescriptor_setDepthPlane :: proc(self: ^RenderPassAttachmentDescriptor, depthPlane: NS.Integer) { +RenderPassAttachmentDescriptor_setDepthPlane :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, depthPlane: NS.Integer) { msgSend(nil, self, "setDepthPlane:", depthPlane) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setLevel") -RenderPassAttachmentDescriptor_setLevel :: proc(self: ^RenderPassAttachmentDescriptor, level: NS.Integer) { +RenderPassAttachmentDescriptor_setLevel :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, level: NS.Integer) { msgSend(nil, self, "setLevel:", level) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setLoadAction") -RenderPassAttachmentDescriptor_setLoadAction :: proc(self: ^RenderPassAttachmentDescriptor, loadAction: LoadAction) { +RenderPassAttachmentDescriptor_setLoadAction :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, loadAction: LoadAction) { msgSend(nil, self, "setLoadAction:", loadAction) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveDepthPlane") -RenderPassAttachmentDescriptor_setResolveDepthPlane :: proc(self: ^RenderPassAttachmentDescriptor, resolveDepthPlane: NS.Integer) { +RenderPassAttachmentDescriptor_setResolveDepthPlane :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, resolveDepthPlane: NS.Integer) { msgSend(nil, self, "setResolveDepthPlane:", resolveDepthPlane) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveLevel") -RenderPassAttachmentDescriptor_setResolveLevel :: proc(self: ^RenderPassAttachmentDescriptor, resolveLevel: NS.Integer) { +RenderPassAttachmentDescriptor_setResolveLevel :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, resolveLevel: NS.Integer) { msgSend(nil, self, "setResolveLevel:", resolveLevel) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveSlice") -RenderPassAttachmentDescriptor_setResolveSlice :: proc(self: ^RenderPassAttachmentDescriptor, resolveSlice: NS.Integer) { +RenderPassAttachmentDescriptor_setResolveSlice :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, resolveSlice: NS.Integer) { msgSend(nil, self, "setResolveSlice:", resolveSlice) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveTexture") -RenderPassAttachmentDescriptor_setResolveTexture :: proc(self: ^RenderPassAttachmentDescriptor, resolveTexture: ^NS.Object) { +RenderPassAttachmentDescriptor_setResolveTexture :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, resolveTexture: ^NS.Object) { msgSend(nil, self, "setResolveTexture:", resolveTexture) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setSlice") -RenderPassAttachmentDescriptor_setSlice :: proc(self: ^RenderPassAttachmentDescriptor, slice: NS.Integer) { +RenderPassAttachmentDescriptor_setSlice :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, slice: NS.Integer) { msgSend(nil, self, "setSlice:", slice) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setStoreAction") -RenderPassAttachmentDescriptor_setStoreAction :: proc(self: ^RenderPassAttachmentDescriptor, storeAction: StoreAction) { +RenderPassAttachmentDescriptor_setStoreAction :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, storeAction: StoreAction) { msgSend(nil, self, "setStoreAction:", storeAction) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setStoreActionOptions") -RenderPassAttachmentDescriptor_setStoreActionOptions :: proc(self: ^RenderPassAttachmentDescriptor, storeActionOptions: StoreActionOptions) { +RenderPassAttachmentDescriptor_setStoreActionOptions :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, storeActionOptions: StoreActionOptions) { msgSend(nil, self, "setStoreActionOptions:", storeActionOptions) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setTexture") -RenderPassAttachmentDescriptor_setTexture :: proc(self: ^RenderPassAttachmentDescriptor, texture: ^NS.Object) { +RenderPassAttachmentDescriptor_setTexture :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, texture: ^NS.Object) { msgSend(nil, self, "setTexture:", texture) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="slice") -RenderPassAttachmentDescriptor_slice :: proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { +RenderPassAttachmentDescriptor_slice :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "slice") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="storeAction") -RenderPassAttachmentDescriptor_storeAction :: proc(self: ^RenderPassAttachmentDescriptor) -> StoreAction { +RenderPassAttachmentDescriptor_storeAction :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> StoreAction { return msgSend(StoreAction, self, "storeAction") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="storeActionOptions") -RenderPassAttachmentDescriptor_storeActionOptions :: proc(self: ^RenderPassAttachmentDescriptor) -> StoreActionOptions { +RenderPassAttachmentDescriptor_storeActionOptions :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> StoreActionOptions { return msgSend(StoreActionOptions, self, "storeActionOptions") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="texture") -RenderPassAttachmentDescriptor_texture :: proc(self: ^RenderPassAttachmentDescriptor) -> ^RenderPassAttachmentDescriptor { +RenderPassAttachmentDescriptor_texture :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> ^RenderPassAttachmentDescriptor { return msgSend(^RenderPassAttachmentDescriptor, self, "texture") } @@ -2592,19 +2578,19 @@ Methods: RenderPassColorAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassColorAttachmentDescriptor) } @(objc_type=RenderPassColorAttachmentDescriptor, objc_class_name="alloc") -RenderPassColorAttachmentDescriptor_alloc :: proc() -> ^RenderPassColorAttachmentDescriptor { +RenderPassColorAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPassColorAttachmentDescriptor { return msgSend(^RenderPassColorAttachmentDescriptor, RenderPassColorAttachmentDescriptor, "alloc") } @(objc_type=RenderPassColorAttachmentDescriptor, objc_name="init") -RenderPassColorAttachmentDescriptor_init :: proc(self: ^RenderPassColorAttachmentDescriptor) -> ^RenderPassColorAttachmentDescriptor { +RenderPassColorAttachmentDescriptor_init :: #force_inline proc(self: ^RenderPassColorAttachmentDescriptor) -> ^RenderPassColorAttachmentDescriptor { return msgSend(^RenderPassColorAttachmentDescriptor, self, "init") } @(objc_type=RenderPassColorAttachmentDescriptor, objc_name="clearColor") -RenderPassColorAttachmentDescriptor_clearColor :: proc(self: ^RenderPassColorAttachmentDescriptor) -> ClearColor { +RenderPassColorAttachmentDescriptor_clearColor :: #force_inline proc(self: ^RenderPassColorAttachmentDescriptor) -> ClearColor { return msgSend(ClearColor, self, "clearColor") } @(objc_type=RenderPassColorAttachmentDescriptor, objc_name="setClearColor") -RenderPassColorAttachmentDescriptor_setClearColor :: proc(self: ^RenderPassColorAttachmentDescriptor, clearColor: ClearColor) { +RenderPassColorAttachmentDescriptor_setClearColor :: #force_inline proc(self: ^RenderPassColorAttachmentDescriptor, clearColor: ClearColor) { msgSend(nil, self, "setClearColor:", clearColor) } @@ -2624,19 +2610,19 @@ Methods: RenderPassColorAttachmentDescriptorArray :: struct { using _: NS.Object } @(objc_type=RenderPassColorAttachmentDescriptorArray, objc_class_name="alloc") -RenderPassColorAttachmentDescriptorArray_alloc :: proc() -> ^RenderPassColorAttachmentDescriptorArray { +RenderPassColorAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^RenderPassColorAttachmentDescriptorArray { return msgSend(^RenderPassColorAttachmentDescriptorArray, RenderPassColorAttachmentDescriptorArray, "alloc") } @(objc_type=RenderPassColorAttachmentDescriptorArray, objc_name="init") -RenderPassColorAttachmentDescriptorArray_init :: proc(self: ^RenderPassColorAttachmentDescriptorArray) -> ^RenderPassColorAttachmentDescriptorArray { +RenderPassColorAttachmentDescriptorArray_init :: #force_inline proc(self: ^RenderPassColorAttachmentDescriptorArray) -> ^RenderPassColorAttachmentDescriptorArray { return msgSend(^RenderPassColorAttachmentDescriptorArray, self, "init") } @(objc_type=RenderPassColorAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -RenderPassColorAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^RenderPassColorAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^RenderPassColorAttachmentDescriptor { +RenderPassColorAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RenderPassColorAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^RenderPassColorAttachmentDescriptor { return msgSend(^RenderPassColorAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=RenderPassColorAttachmentDescriptorArray, objc_name="setObject") -RenderPassColorAttachmentDescriptorArray_setObject :: proc(self: ^RenderPassColorAttachmentDescriptorArray, attachment: ^RenderPassColorAttachmentDescriptor, attachmentIndex: ^NS.Object) { +RenderPassColorAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^RenderPassColorAttachmentDescriptorArray, attachment: ^RenderPassColorAttachmentDescriptor, attachmentIndex: ^NS.Object) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -2658,27 +2644,27 @@ Methods: RenderPassDepthAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassDepthAttachmentDescriptor) } @(objc_type=RenderPassDepthAttachmentDescriptor, objc_class_name="alloc") -RenderPassDepthAttachmentDescriptor_alloc :: proc() -> ^RenderPassDepthAttachmentDescriptor { +RenderPassDepthAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPassDepthAttachmentDescriptor { return msgSend(^RenderPassDepthAttachmentDescriptor, RenderPassDepthAttachmentDescriptor, "alloc") } @(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="init") -RenderPassDepthAttachmentDescriptor_init :: proc(self: ^RenderPassDepthAttachmentDescriptor) -> ^RenderPassDepthAttachmentDescriptor { +RenderPassDepthAttachmentDescriptor_init :: #force_inline proc(self: ^RenderPassDepthAttachmentDescriptor) -> ^RenderPassDepthAttachmentDescriptor { return msgSend(^RenderPassDepthAttachmentDescriptor, self, "init") } @(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="clearDepth") -RenderPassDepthAttachmentDescriptor_clearDepth :: proc(self: ^RenderPassDepthAttachmentDescriptor) -> f64 { +RenderPassDepthAttachmentDescriptor_clearDepth :: #force_inline proc(self: ^RenderPassDepthAttachmentDescriptor) -> f64 { return msgSend(f64, self, "clearDepth") } @(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="depthResolveFilter") -RenderPassDepthAttachmentDescriptor_depthResolveFilter :: proc(self: ^RenderPassDepthAttachmentDescriptor) -> MultisampleDepthResolveFilter { +RenderPassDepthAttachmentDescriptor_depthResolveFilter :: #force_inline proc(self: ^RenderPassDepthAttachmentDescriptor) -> MultisampleDepthResolveFilter { return msgSend(MultisampleDepthResolveFilter, self, "depthResolveFilter") } @(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="setClearDepth") -RenderPassDepthAttachmentDescriptor_setClearDepth :: proc(self: ^RenderPassDepthAttachmentDescriptor, clearDepth: f64) { +RenderPassDepthAttachmentDescriptor_setClearDepth :: #force_inline proc(self: ^RenderPassDepthAttachmentDescriptor, clearDepth: f64) { msgSend(nil, self, "setClearDepth:", clearDepth) } @(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="setDepthResolveFilter") -RenderPassDepthAttachmentDescriptor_setDepthResolveFilter :: proc(self: ^RenderPassDepthAttachmentDescriptor, depthResolveFilter: MultisampleDepthResolveFilter) { +RenderPassDepthAttachmentDescriptor_setDepthResolveFilter :: #force_inline proc(self: ^RenderPassDepthAttachmentDescriptor, depthResolveFilter: MultisampleDepthResolveFilter) { msgSend(nil, self, "setDepthResolveFilter:", depthResolveFilter) } @@ -2725,127 +2711,127 @@ Methods: RenderPassDescriptor :: struct { using _: NS.Copying(RenderPassDescriptor) } @(objc_type=RenderPassDescriptor, objc_class_name="alloc") -RenderPassDescriptor_alloc :: proc() -> ^RenderPassDescriptor { +RenderPassDescriptor_alloc :: #force_inline proc() -> ^RenderPassDescriptor { return msgSend(^RenderPassDescriptor, RenderPassDescriptor, "alloc") } @(objc_type=RenderPassDescriptor, objc_name="init") -RenderPassDescriptor_init :: proc(self: ^RenderPassDescriptor) -> ^RenderPassDescriptor { +RenderPassDescriptor_init :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RenderPassDescriptor { return msgSend(^RenderPassDescriptor, self, "init") } @(objc_type=RenderPassDescriptor, objc_name="colorAttachments") -RenderPassDescriptor_colorAttachments :: proc(self: ^RenderPassDescriptor) -> ^RenderPassColorAttachmentDescriptorArray { +RenderPassDescriptor_colorAttachments :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RenderPassColorAttachmentDescriptorArray { return msgSend(^RenderPassColorAttachmentDescriptorArray, self, "colorAttachments") } @(objc_type=RenderPassDescriptor, objc_name="defaultRasterSampleCount") -RenderPassDescriptor_defaultRasterSampleCount :: proc(self: ^RenderPassDescriptor) -> NS.Integer { +RenderPassDescriptor_defaultRasterSampleCount :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "defaultRasterSampleCount") } @(objc_type=RenderPassDescriptor, objc_name="depthAttachment") -RenderPassDescriptor_depthAttachment :: proc(self: ^RenderPassDescriptor) -> ^RenderPassDepthAttachmentDescriptor { +RenderPassDescriptor_depthAttachment :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RenderPassDepthAttachmentDescriptor { return msgSend(^RenderPassDepthAttachmentDescriptor, self, "depthAttachment") } @(objc_type=RenderPassDescriptor, objc_name="getSamplePositions") -RenderPassDescriptor_getSamplePositions :: proc(self: ^RenderPassDescriptor, positions: ^SamplePosition, count: ^NS.Object) -> ^RenderPassDescriptor { +RenderPassDescriptor_getSamplePositions :: #force_inline proc(self: ^RenderPassDescriptor, positions: ^SamplePosition, count: ^NS.Object) -> ^RenderPassDescriptor { return msgSend(^RenderPassDescriptor, self, "getSamplePositions:count:", positions, count) } @(objc_type=RenderPassDescriptor, objc_name="imageblockSampleLength") -RenderPassDescriptor_imageblockSampleLength :: proc(self: ^RenderPassDescriptor) -> NS.Integer { +RenderPassDescriptor_imageblockSampleLength :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "imageblockSampleLength") } @(objc_type=RenderPassDescriptor, objc_name="rasterizationRateMap") -RenderPassDescriptor_rasterizationRateMap :: proc(self: ^RenderPassDescriptor) -> ^RenderPassDescriptor { +RenderPassDescriptor_rasterizationRateMap :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RenderPassDescriptor { return msgSend(^RenderPassDescriptor, self, "rasterizationRateMap") } @(objc_type=RenderPassDescriptor, objc_class_name="renderPassDescriptor") -RenderPassDescriptor_renderPassDescriptor :: proc() -> ^RenderPassDescriptor { +RenderPassDescriptor_renderPassDescriptor :: #force_inline proc() -> ^RenderPassDescriptor { return msgSend(^RenderPassDescriptor, RenderPassDescriptor, "renderPassDescriptor") } @(objc_type=RenderPassDescriptor, objc_name="renderTargetArrayLength") -RenderPassDescriptor_renderTargetArrayLength :: proc(self: ^RenderPassDescriptor) -> NS.Integer { +RenderPassDescriptor_renderTargetArrayLength :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "renderTargetArrayLength") } @(objc_type=RenderPassDescriptor, objc_name="renderTargetHeight") -RenderPassDescriptor_renderTargetHeight :: proc(self: ^RenderPassDescriptor) -> NS.Integer { +RenderPassDescriptor_renderTargetHeight :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "renderTargetHeight") } @(objc_type=RenderPassDescriptor, objc_name="renderTargetWidth") -RenderPassDescriptor_renderTargetWidth :: proc(self: ^RenderPassDescriptor) -> NS.Integer { +RenderPassDescriptor_renderTargetWidth :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "renderTargetWidth") } @(objc_type=RenderPassDescriptor, objc_name="sampleBufferAttachments") -RenderPassDescriptor_sampleBufferAttachments :: proc(self: ^RenderPassDescriptor) -> ^RenderPassSampleBufferAttachmentDescriptorArray { +RenderPassDescriptor_sampleBufferAttachments :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RenderPassSampleBufferAttachmentDescriptorArray { return msgSend(^RenderPassSampleBufferAttachmentDescriptorArray, self, "sampleBufferAttachments") } @(objc_type=RenderPassDescriptor, objc_name="setDefaultRasterSampleCount") -RenderPassDescriptor_setDefaultRasterSampleCount :: proc(self: ^RenderPassDescriptor, defaultRasterSampleCount: NS.Integer) { +RenderPassDescriptor_setDefaultRasterSampleCount :: #force_inline proc(self: ^RenderPassDescriptor, defaultRasterSampleCount: NS.Integer) { msgSend(nil, self, "setDefaultRasterSampleCount:", defaultRasterSampleCount) } @(objc_type=RenderPassDescriptor, objc_name="setDepthAttachment") -RenderPassDescriptor_setDepthAttachment :: proc(self: ^RenderPassDescriptor, depthAttachment: ^RenderPassDepthAttachmentDescriptor) { +RenderPassDescriptor_setDepthAttachment :: #force_inline proc(self: ^RenderPassDescriptor, depthAttachment: ^RenderPassDepthAttachmentDescriptor) { msgSend(nil, self, "setDepthAttachment:", depthAttachment) } @(objc_type=RenderPassDescriptor, objc_name="setImageblockSampleLength") -RenderPassDescriptor_setImageblockSampleLength :: proc(self: ^RenderPassDescriptor, imageblockSampleLength: NS.Integer) { +RenderPassDescriptor_setImageblockSampleLength :: #force_inline proc(self: ^RenderPassDescriptor, imageblockSampleLength: NS.Integer) { msgSend(nil, self, "setImageblockSampleLength:", imageblockSampleLength) } @(objc_type=RenderPassDescriptor, objc_name="setRasterizationRateMap") -RenderPassDescriptor_setRasterizationRateMap :: proc(self: ^RenderPassDescriptor, rasterizationRateMap: ^NS.Object) { +RenderPassDescriptor_setRasterizationRateMap :: #force_inline proc(self: ^RenderPassDescriptor, rasterizationRateMap: ^NS.Object) { msgSend(nil, self, "setRasterizationRateMap:", rasterizationRateMap) } @(objc_type=RenderPassDescriptor, objc_name="setRenderTargetArrayLength") -RenderPassDescriptor_setRenderTargetArrayLength :: proc(self: ^RenderPassDescriptor, renderTargetArrayLength: NS.Integer) { +RenderPassDescriptor_setRenderTargetArrayLength :: #force_inline proc(self: ^RenderPassDescriptor, renderTargetArrayLength: NS.Integer) { msgSend(nil, self, "setRenderTargetArrayLength:", renderTargetArrayLength) } @(objc_type=RenderPassDescriptor, objc_name="setRenderTargetHeight") -RenderPassDescriptor_setRenderTargetHeight :: proc(self: ^RenderPassDescriptor, renderTargetHeight: NS.Integer) { +RenderPassDescriptor_setRenderTargetHeight :: #force_inline proc(self: ^RenderPassDescriptor, renderTargetHeight: NS.Integer) { msgSend(nil, self, "setRenderTargetHeight:", renderTargetHeight) } @(objc_type=RenderPassDescriptor, objc_name="setRenderTargetWidth") -RenderPassDescriptor_setRenderTargetWidth :: proc(self: ^RenderPassDescriptor, renderTargetWidth: NS.Integer) { +RenderPassDescriptor_setRenderTargetWidth :: #force_inline proc(self: ^RenderPassDescriptor, renderTargetWidth: NS.Integer) { msgSend(nil, self, "setRenderTargetWidth:", renderTargetWidth) } @(objc_type=RenderPassDescriptor, objc_name="setSamplePositions") -RenderPassDescriptor_setSamplePositions :: proc(self: ^RenderPassDescriptor, positions: ^SamplePosition, count: ^NS.Object) { +RenderPassDescriptor_setSamplePositions :: #force_inline proc(self: ^RenderPassDescriptor, positions: ^SamplePosition, count: ^NS.Object) { msgSend(nil, self, "setSamplePositions:count:", positions, count) } @(objc_type=RenderPassDescriptor, objc_name="setStencilAttachment") -RenderPassDescriptor_setStencilAttachment :: proc(self: ^RenderPassDescriptor, stencilAttachment: ^RenderPassStencilAttachmentDescriptor) { +RenderPassDescriptor_setStencilAttachment :: #force_inline proc(self: ^RenderPassDescriptor, stencilAttachment: ^RenderPassStencilAttachmentDescriptor) { msgSend(nil, self, "setStencilAttachment:", stencilAttachment) } @(objc_type=RenderPassDescriptor, objc_name="setThreadgroupMemoryLength") -RenderPassDescriptor_setThreadgroupMemoryLength :: proc(self: ^RenderPassDescriptor, threadgroupMemoryLength: NS.Integer) { +RenderPassDescriptor_setThreadgroupMemoryLength :: #force_inline proc(self: ^RenderPassDescriptor, threadgroupMemoryLength: NS.Integer) { msgSend(nil, self, "setThreadgroupMemoryLength:", threadgroupMemoryLength) } @(objc_type=RenderPassDescriptor, objc_name="setTileHeight") -RenderPassDescriptor_setTileHeight :: proc(self: ^RenderPassDescriptor, tileHeight: NS.Integer) { +RenderPassDescriptor_setTileHeight :: #force_inline proc(self: ^RenderPassDescriptor, tileHeight: NS.Integer) { msgSend(nil, self, "setTileHeight:", tileHeight) } @(objc_type=RenderPassDescriptor, objc_name="setTileWidth") -RenderPassDescriptor_setTileWidth :: proc(self: ^RenderPassDescriptor, tileWidth: NS.Integer) { +RenderPassDescriptor_setTileWidth :: #force_inline proc(self: ^RenderPassDescriptor, tileWidth: NS.Integer) { msgSend(nil, self, "setTileWidth:", tileWidth) } @(objc_type=RenderPassDescriptor, objc_name="setVisibilityResultBuffer") -RenderPassDescriptor_setVisibilityResultBuffer :: proc(self: ^RenderPassDescriptor, visibilityResultBuffer: ^NS.Object) { +RenderPassDescriptor_setVisibilityResultBuffer :: #force_inline proc(self: ^RenderPassDescriptor, visibilityResultBuffer: ^NS.Object) { msgSend(nil, self, "setVisibilityResultBuffer:", visibilityResultBuffer) } @(objc_type=RenderPassDescriptor, objc_name="stencilAttachment") -RenderPassDescriptor_stencilAttachment :: proc(self: ^RenderPassDescriptor) -> ^RenderPassStencilAttachmentDescriptor { +RenderPassDescriptor_stencilAttachment :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RenderPassStencilAttachmentDescriptor { return msgSend(^RenderPassStencilAttachmentDescriptor, self, "stencilAttachment") } @(objc_type=RenderPassDescriptor, objc_name="threadgroupMemoryLength") -RenderPassDescriptor_threadgroupMemoryLength :: proc(self: ^RenderPassDescriptor) -> NS.Integer { +RenderPassDescriptor_threadgroupMemoryLength :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "threadgroupMemoryLength") } @(objc_type=RenderPassDescriptor, objc_name="tileHeight") -RenderPassDescriptor_tileHeight :: proc(self: ^RenderPassDescriptor) -> NS.Integer { +RenderPassDescriptor_tileHeight :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "tileHeight") } @(objc_type=RenderPassDescriptor, objc_name="tileWidth") -RenderPassDescriptor_tileWidth :: proc(self: ^RenderPassDescriptor) -> NS.Integer { +RenderPassDescriptor_tileWidth :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "tileWidth") } @(objc_type=RenderPassDescriptor, objc_name="visibilityResultBuffer") -RenderPassDescriptor_visibilityResultBuffer :: proc(self: ^RenderPassDescriptor) -> ^RenderPassDescriptor { +RenderPassDescriptor_visibilityResultBuffer :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RenderPassDescriptor { return msgSend(^RenderPassDescriptor, self, "visibilityResultBuffer") } @@ -2873,51 +2859,51 @@ Methods: RenderPassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassSampleBufferAttachmentDescriptor) } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_class_name="alloc") -RenderPassSampleBufferAttachmentDescriptor_alloc :: proc() -> ^RenderPassSampleBufferAttachmentDescriptor { +RenderPassSampleBufferAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPassSampleBufferAttachmentDescriptor { return msgSend(^RenderPassSampleBufferAttachmentDescriptor, RenderPassSampleBufferAttachmentDescriptor, "alloc") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="init") -RenderPassSampleBufferAttachmentDescriptor_init :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> ^RenderPassSampleBufferAttachmentDescriptor { +RenderPassSampleBufferAttachmentDescriptor_init :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> ^RenderPassSampleBufferAttachmentDescriptor { return msgSend(^RenderPassSampleBufferAttachmentDescriptor, self, "init") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="endOfFragmentSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_endOfFragmentSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer { +RenderPassSampleBufferAttachmentDescriptor_endOfFragmentSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "endOfFragmentSampleIndex") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="endOfVertexSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_endOfVertexSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer { +RenderPassSampleBufferAttachmentDescriptor_endOfVertexSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "endOfVertexSampleIndex") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") -RenderPassSampleBufferAttachmentDescriptor_sampleBuffer :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> ^RenderPassSampleBufferAttachmentDescriptor { +RenderPassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> ^RenderPassSampleBufferAttachmentDescriptor { return msgSend(^RenderPassSampleBufferAttachmentDescriptor, self, "sampleBuffer") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setEndOfFragmentSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_setEndOfFragmentSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor, endOfFragmentSampleIndex: NS.Integer) { +RenderPassSampleBufferAttachmentDescriptor_setEndOfFragmentSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, endOfFragmentSampleIndex: NS.Integer) { msgSend(nil, self, "setEndOfFragmentSampleIndex:", endOfFragmentSampleIndex) } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setEndOfVertexSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_setEndOfVertexSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor, endOfVertexSampleIndex: NS.Integer) { +RenderPassSampleBufferAttachmentDescriptor_setEndOfVertexSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, endOfVertexSampleIndex: NS.Integer) { msgSend(nil, self, "setEndOfVertexSampleIndex:", endOfVertexSampleIndex) } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") -RenderPassSampleBufferAttachmentDescriptor_setSampleBuffer :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) { +RenderPassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) { msgSend(nil, self, "setSampleBuffer:", sampleBuffer) } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setStartOfFragmentSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_setStartOfFragmentSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor, startOfFragmentSampleIndex: NS.Integer) { +RenderPassSampleBufferAttachmentDescriptor_setStartOfFragmentSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, startOfFragmentSampleIndex: NS.Integer) { msgSend(nil, self, "setStartOfFragmentSampleIndex:", startOfFragmentSampleIndex) } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setStartOfVertexSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_setStartOfVertexSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor, startOfVertexSampleIndex: NS.Integer) { +RenderPassSampleBufferAttachmentDescriptor_setStartOfVertexSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, startOfVertexSampleIndex: NS.Integer) { msgSend(nil, self, "setStartOfVertexSampleIndex:", startOfVertexSampleIndex) } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="startOfFragmentSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_startOfFragmentSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer { +RenderPassSampleBufferAttachmentDescriptor_startOfFragmentSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "startOfFragmentSampleIndex") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="startOfVertexSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_startOfVertexSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer { +RenderPassSampleBufferAttachmentDescriptor_startOfVertexSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "startOfVertexSampleIndex") } @@ -2937,19 +2923,19 @@ Methods: RenderPassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object } @(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_class_name="alloc") -RenderPassSampleBufferAttachmentDescriptorArray_alloc :: proc() -> ^RenderPassSampleBufferAttachmentDescriptorArray { +RenderPassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^RenderPassSampleBufferAttachmentDescriptorArray { return msgSend(^RenderPassSampleBufferAttachmentDescriptorArray, RenderPassSampleBufferAttachmentDescriptorArray, "alloc") } @(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_name="init") -RenderPassSampleBufferAttachmentDescriptorArray_init :: proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray) -> ^RenderPassSampleBufferAttachmentDescriptorArray { +RenderPassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray) -> ^RenderPassSampleBufferAttachmentDescriptorArray { return msgSend(^RenderPassSampleBufferAttachmentDescriptorArray, self, "init") } @(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -RenderPassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^RenderPassSampleBufferAttachmentDescriptor { +RenderPassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^RenderPassSampleBufferAttachmentDescriptor { return msgSend(^RenderPassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_name="setObject") -RenderPassSampleBufferAttachmentDescriptorArray_setObject :: proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray, attachment: ^RenderPassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) { +RenderPassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray, attachment: ^RenderPassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -2971,27 +2957,27 @@ Methods: RenderPassStencilAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassStencilAttachmentDescriptor) } @(objc_type=RenderPassStencilAttachmentDescriptor, objc_class_name="alloc") -RenderPassStencilAttachmentDescriptor_alloc :: proc() -> ^RenderPassStencilAttachmentDescriptor { +RenderPassStencilAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPassStencilAttachmentDescriptor { return msgSend(^RenderPassStencilAttachmentDescriptor, RenderPassStencilAttachmentDescriptor, "alloc") } @(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="init") -RenderPassStencilAttachmentDescriptor_init :: proc(self: ^RenderPassStencilAttachmentDescriptor) -> ^RenderPassStencilAttachmentDescriptor { +RenderPassStencilAttachmentDescriptor_init :: #force_inline proc(self: ^RenderPassStencilAttachmentDescriptor) -> ^RenderPassStencilAttachmentDescriptor { return msgSend(^RenderPassStencilAttachmentDescriptor, self, "init") } @(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="clearStencil") -RenderPassStencilAttachmentDescriptor_clearStencil :: proc(self: ^RenderPassStencilAttachmentDescriptor) -> u32 { +RenderPassStencilAttachmentDescriptor_clearStencil :: #force_inline proc(self: ^RenderPassStencilAttachmentDescriptor) -> u32 { return msgSend(u32, self, "clearStencil") } @(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="setClearStencil") -RenderPassStencilAttachmentDescriptor_setClearStencil :: proc(self: ^RenderPassStencilAttachmentDescriptor, clearStencil: u32) { +RenderPassStencilAttachmentDescriptor_setClearStencil :: #force_inline proc(self: ^RenderPassStencilAttachmentDescriptor, clearStencil: u32) { msgSend(nil, self, "setClearStencil:", clearStencil) } @(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="setStencilResolveFilter") -RenderPassStencilAttachmentDescriptor_setStencilResolveFilter :: proc(self: ^RenderPassStencilAttachmentDescriptor, stencilResolveFilter: MultisampleStencilResolveFilter) { +RenderPassStencilAttachmentDescriptor_setStencilResolveFilter :: #force_inline proc(self: ^RenderPassStencilAttachmentDescriptor, stencilResolveFilter: MultisampleStencilResolveFilter) { msgSend(nil, self, "setStencilResolveFilter:", stencilResolveFilter) } @(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="stencilResolveFilter") -RenderPassStencilAttachmentDescriptor_stencilResolveFilter :: proc(self: ^RenderPassStencilAttachmentDescriptor) -> MultisampleStencilResolveFilter { +RenderPassStencilAttachmentDescriptor_stencilResolveFilter :: #force_inline proc(self: ^RenderPassStencilAttachmentDescriptor) -> MultisampleStencilResolveFilter { return msgSend(MultisampleStencilResolveFilter, self, "stencilResolveFilter") } @@ -3027,83 +3013,83 @@ Methods: RenderPipelineColorAttachmentDescriptor :: struct { using _: NS.Copying(RenderPipelineColorAttachmentDescriptor) } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_class_name="alloc") -RenderPipelineColorAttachmentDescriptor_alloc :: proc() -> ^RenderPipelineColorAttachmentDescriptor { +RenderPipelineColorAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPipelineColorAttachmentDescriptor { return msgSend(^RenderPipelineColorAttachmentDescriptor, RenderPipelineColorAttachmentDescriptor, "alloc") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="init") -RenderPipelineColorAttachmentDescriptor_init :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> ^RenderPipelineColorAttachmentDescriptor { +RenderPipelineColorAttachmentDescriptor_init :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> ^RenderPipelineColorAttachmentDescriptor { return msgSend(^RenderPipelineColorAttachmentDescriptor, self, "init") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="alphaBlendOperation") -RenderPipelineColorAttachmentDescriptor_alphaBlendOperation :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendOperation { +RenderPipelineColorAttachmentDescriptor_alphaBlendOperation :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendOperation { return msgSend(BlendOperation, self, "alphaBlendOperation") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="destinationAlphaBlendFactor") -RenderPipelineColorAttachmentDescriptor_destinationAlphaBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { +RenderPipelineColorAttachmentDescriptor_destinationAlphaBlendFactor :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { return msgSend(BlendFactor, self, "destinationAlphaBlendFactor") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="destinationRGBBlendFactor") -RenderPipelineColorAttachmentDescriptor_destinationRGBBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { +RenderPipelineColorAttachmentDescriptor_destinationRGBBlendFactor :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { return msgSend(BlendFactor, self, "destinationRGBBlendFactor") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="isBlendingEnabled") -RenderPipelineColorAttachmentDescriptor_isBlendingEnabled :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BOOL { +RenderPipelineColorAttachmentDescriptor_isBlendingEnabled :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BOOL { return msgSend(BOOL, self, "isBlendingEnabled") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="pixelFormat") -RenderPipelineColorAttachmentDescriptor_pixelFormat :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> PixelFormat { +RenderPipelineColorAttachmentDescriptor_pixelFormat :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> PixelFormat { return msgSend(PixelFormat, self, "pixelFormat") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="rgbBlendOperation") -RenderPipelineColorAttachmentDescriptor_rgbBlendOperation :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendOperation { +RenderPipelineColorAttachmentDescriptor_rgbBlendOperation :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendOperation { return msgSend(BlendOperation, self, "rgbBlendOperation") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setAlphaBlendOperation") -RenderPipelineColorAttachmentDescriptor_setAlphaBlendOperation :: proc(self: ^RenderPipelineColorAttachmentDescriptor, alphaBlendOperation: BlendOperation) { +RenderPipelineColorAttachmentDescriptor_setAlphaBlendOperation :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor, alphaBlendOperation: BlendOperation) { msgSend(nil, self, "setAlphaBlendOperation:", alphaBlendOperation) } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setBlendingEnabled") -RenderPipelineColorAttachmentDescriptor_setBlendingEnabled :: proc(self: ^RenderPipelineColorAttachmentDescriptor, blendingEnabled: BOOL) { +RenderPipelineColorAttachmentDescriptor_setBlendingEnabled :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor, blendingEnabled: BOOL) { msgSend(nil, self, "setBlendingEnabled:", blendingEnabled) } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setDestinationAlphaBlendFactor") -RenderPipelineColorAttachmentDescriptor_setDestinationAlphaBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor, destinationAlphaBlendFactor: BlendFactor) { +RenderPipelineColorAttachmentDescriptor_setDestinationAlphaBlendFactor :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor, destinationAlphaBlendFactor: BlendFactor) { msgSend(nil, self, "setDestinationAlphaBlendFactor:", destinationAlphaBlendFactor) } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setDestinationRGBBlendFactor") -RenderPipelineColorAttachmentDescriptor_setDestinationRGBBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor, destinationRGBBlendFactor: BlendFactor) { +RenderPipelineColorAttachmentDescriptor_setDestinationRGBBlendFactor :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor, destinationRGBBlendFactor: BlendFactor) { msgSend(nil, self, "setDestinationRGBBlendFactor:", destinationRGBBlendFactor) } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setPixelFormat") -RenderPipelineColorAttachmentDescriptor_setPixelFormat :: proc(self: ^RenderPipelineColorAttachmentDescriptor, pixelFormat: PixelFormat) { +RenderPipelineColorAttachmentDescriptor_setPixelFormat :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor, pixelFormat: PixelFormat) { msgSend(nil, self, "setPixelFormat:", pixelFormat) } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setRgbBlendOperation") -RenderPipelineColorAttachmentDescriptor_setRgbBlendOperation :: proc(self: ^RenderPipelineColorAttachmentDescriptor, rgbBlendOperation: BlendOperation) { +RenderPipelineColorAttachmentDescriptor_setRgbBlendOperation :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor, rgbBlendOperation: BlendOperation) { msgSend(nil, self, "setRgbBlendOperation:", rgbBlendOperation) } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setSourceAlphaBlendFactor") -RenderPipelineColorAttachmentDescriptor_setSourceAlphaBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor, sourceAlphaBlendFactor: BlendFactor) { +RenderPipelineColorAttachmentDescriptor_setSourceAlphaBlendFactor :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor, sourceAlphaBlendFactor: BlendFactor) { msgSend(nil, self, "setSourceAlphaBlendFactor:", sourceAlphaBlendFactor) } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setSourceRGBBlendFactor") -RenderPipelineColorAttachmentDescriptor_setSourceRGBBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor, sourceRGBBlendFactor: BlendFactor) { +RenderPipelineColorAttachmentDescriptor_setSourceRGBBlendFactor :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor, sourceRGBBlendFactor: BlendFactor) { msgSend(nil, self, "setSourceRGBBlendFactor:", sourceRGBBlendFactor) } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setWriteMask") -RenderPipelineColorAttachmentDescriptor_setWriteMask :: proc(self: ^RenderPipelineColorAttachmentDescriptor, writeMask: ColorWriteMask) { +RenderPipelineColorAttachmentDescriptor_setWriteMask :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor, writeMask: ColorWriteMask) { msgSend(nil, self, "setWriteMask:", writeMask) } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="sourceAlphaBlendFactor") -RenderPipelineColorAttachmentDescriptor_sourceAlphaBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { +RenderPipelineColorAttachmentDescriptor_sourceAlphaBlendFactor :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { return msgSend(BlendFactor, self, "sourceAlphaBlendFactor") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="sourceRGBBlendFactor") -RenderPipelineColorAttachmentDescriptor_sourceRGBBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { +RenderPipelineColorAttachmentDescriptor_sourceRGBBlendFactor :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { return msgSend(BlendFactor, self, "sourceRGBBlendFactor") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="writeMask") -RenderPipelineColorAttachmentDescriptor_writeMask :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> ColorWriteMask { +RenderPipelineColorAttachmentDescriptor_writeMask :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> ColorWriteMask { return msgSend(ColorWriteMask, self, "writeMask") } @@ -3123,19 +3109,19 @@ Methods: RenderPipelineColorAttachmentDescriptorArray :: struct { using _: NS.Object } @(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_class_name="alloc") -RenderPipelineColorAttachmentDescriptorArray_alloc :: proc() -> ^RenderPipelineColorAttachmentDescriptorArray { +RenderPipelineColorAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^RenderPipelineColorAttachmentDescriptorArray { return msgSend(^RenderPipelineColorAttachmentDescriptorArray, RenderPipelineColorAttachmentDescriptorArray, "alloc") } @(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_name="init") -RenderPipelineColorAttachmentDescriptorArray_init :: proc(self: ^RenderPipelineColorAttachmentDescriptorArray) -> ^RenderPipelineColorAttachmentDescriptorArray { +RenderPipelineColorAttachmentDescriptorArray_init :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptorArray) -> ^RenderPipelineColorAttachmentDescriptorArray { return msgSend(^RenderPipelineColorAttachmentDescriptorArray, self, "init") } @(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -RenderPipelineColorAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^RenderPipelineColorAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^RenderPipelineColorAttachmentDescriptor { +RenderPipelineColorAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^RenderPipelineColorAttachmentDescriptor { return msgSend(^RenderPipelineColorAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_name="setObject") -RenderPipelineColorAttachmentDescriptorArray_setObject :: proc(self: ^RenderPipelineColorAttachmentDescriptorArray, attachment: ^RenderPipelineColorAttachmentDescriptor, attachmentIndex: ^NS.Object) { +RenderPipelineColorAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptorArray, attachment: ^RenderPipelineColorAttachmentDescriptor, attachmentIndex: ^NS.Object) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -3201,203 +3187,203 @@ Methods: RenderPipelineDescriptor :: struct { using _: NS.Copying(RenderPipelineDescriptor) } @(objc_type=RenderPipelineDescriptor, objc_class_name="alloc") -RenderPipelineDescriptor_alloc :: proc() -> ^RenderPipelineDescriptor { +RenderPipelineDescriptor_alloc :: #force_inline proc() -> ^RenderPipelineDescriptor { return msgSend(^RenderPipelineDescriptor, RenderPipelineDescriptor, "alloc") } @(objc_type=RenderPipelineDescriptor, objc_name="init") -RenderPipelineDescriptor_init :: proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineDescriptor { +RenderPipelineDescriptor_init :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineDescriptor { return msgSend(^RenderPipelineDescriptor, self, "init") } @(objc_type=RenderPipelineDescriptor, objc_name="binaryArchives") -RenderPipelineDescriptor_binaryArchives :: proc(self: ^RenderPipelineDescriptor) -> ^NS.Array { +RenderPipelineDescriptor_binaryArchives :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^NS.Array { return msgSend(^NS.Array, self, "binaryArchives") } @(objc_type=RenderPipelineDescriptor, objc_name="colorAttachments") -RenderPipelineDescriptor_colorAttachments :: proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineColorAttachmentDescriptorArray { +RenderPipelineDescriptor_colorAttachments :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineColorAttachmentDescriptorArray { return msgSend(^RenderPipelineColorAttachmentDescriptorArray, self, "colorAttachments") } @(objc_type=RenderPipelineDescriptor, objc_name="depthAttachmentPixelFormat") -RenderPipelineDescriptor_depthAttachmentPixelFormat :: proc(self: ^RenderPipelineDescriptor) -> PixelFormat { +RenderPipelineDescriptor_depthAttachmentPixelFormat :: #force_inline proc(self: ^RenderPipelineDescriptor) -> PixelFormat { return msgSend(PixelFormat, self, "depthAttachmentPixelFormat") } @(objc_type=RenderPipelineDescriptor, objc_name="fragmentBuffers") -RenderPipelineDescriptor_fragmentBuffers :: proc(self: ^RenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray { +RenderPipelineDescriptor_fragmentBuffers :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray { return msgSend(^PipelineBufferDescriptorArray, self, "fragmentBuffers") } @(objc_type=RenderPipelineDescriptor, objc_name="fragmentFunction") -RenderPipelineDescriptor_fragmentFunction :: proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineDescriptor { +RenderPipelineDescriptor_fragmentFunction :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineDescriptor { return msgSend(^RenderPipelineDescriptor, self, "fragmentFunction") } @(objc_type=RenderPipelineDescriptor, objc_name="inputPrimitiveTopology") -RenderPipelineDescriptor_inputPrimitiveTopology :: proc(self: ^RenderPipelineDescriptor) -> PrimitiveTopologyClass { +RenderPipelineDescriptor_inputPrimitiveTopology :: #force_inline proc(self: ^RenderPipelineDescriptor) -> PrimitiveTopologyClass { return msgSend(PrimitiveTopologyClass, self, "inputPrimitiveTopology") } @(objc_type=RenderPipelineDescriptor, objc_name="isAlphaToCoverageEnabled") -RenderPipelineDescriptor_isAlphaToCoverageEnabled :: proc(self: ^RenderPipelineDescriptor) -> BOOL { +RenderPipelineDescriptor_isAlphaToCoverageEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "isAlphaToCoverageEnabled") } @(objc_type=RenderPipelineDescriptor, objc_name="isAlphaToOneEnabled") -RenderPipelineDescriptor_isAlphaToOneEnabled :: proc(self: ^RenderPipelineDescriptor) -> BOOL { +RenderPipelineDescriptor_isAlphaToOneEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "isAlphaToOneEnabled") } @(objc_type=RenderPipelineDescriptor, objc_name="isRasterizationEnabled") -RenderPipelineDescriptor_isRasterizationEnabled :: proc(self: ^RenderPipelineDescriptor) -> BOOL { +RenderPipelineDescriptor_isRasterizationEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "isRasterizationEnabled") } @(objc_type=RenderPipelineDescriptor, objc_name="isTessellationFactorScaleEnabled") -RenderPipelineDescriptor_isTessellationFactorScaleEnabled :: proc(self: ^RenderPipelineDescriptor) -> BOOL { +RenderPipelineDescriptor_isTessellationFactorScaleEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "isTessellationFactorScaleEnabled") } @(objc_type=RenderPipelineDescriptor, objc_name="label") -RenderPipelineDescriptor_label :: proc(self: ^RenderPipelineDescriptor) -> ^NS.String { +RenderPipelineDescriptor_label :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=RenderPipelineDescriptor, objc_name="maxTessellationFactor") -RenderPipelineDescriptor_maxTessellationFactor :: proc(self: ^RenderPipelineDescriptor) -> NS.Integer { +RenderPipelineDescriptor_maxTessellationFactor :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "maxTessellationFactor") } @(objc_type=RenderPipelineDescriptor, objc_name="maxVertexAmplificationCount") -RenderPipelineDescriptor_maxVertexAmplificationCount :: proc(self: ^RenderPipelineDescriptor) -> NS.Integer { +RenderPipelineDescriptor_maxVertexAmplificationCount :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "maxVertexAmplificationCount") } @(objc_type=RenderPipelineDescriptor, objc_name="rasterSampleCount") -RenderPipelineDescriptor_rasterSampleCount :: proc(self: ^RenderPipelineDescriptor) -> NS.Integer { +RenderPipelineDescriptor_rasterSampleCount :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "rasterSampleCount") } @(objc_type=RenderPipelineDescriptor, objc_name="reset") -RenderPipelineDescriptor_reset :: proc(self: ^RenderPipelineDescriptor) { +RenderPipelineDescriptor_reset :: #force_inline proc(self: ^RenderPipelineDescriptor) { msgSend(nil, self, "reset") } @(objc_type=RenderPipelineDescriptor, objc_name="sampleCount") -RenderPipelineDescriptor_sampleCount :: proc(self: ^RenderPipelineDescriptor) -> NS.Integer { +RenderPipelineDescriptor_sampleCount :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "sampleCount") } @(objc_type=RenderPipelineDescriptor, objc_name="setAlphaToCoverageEnabled") -RenderPipelineDescriptor_setAlphaToCoverageEnabled :: proc(self: ^RenderPipelineDescriptor, alphaToCoverageEnabled: BOOL) { +RenderPipelineDescriptor_setAlphaToCoverageEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor, alphaToCoverageEnabled: BOOL) { msgSend(nil, self, "setAlphaToCoverageEnabled:", alphaToCoverageEnabled) } @(objc_type=RenderPipelineDescriptor, objc_name="setAlphaToOneEnabled") -RenderPipelineDescriptor_setAlphaToOneEnabled :: proc(self: ^RenderPipelineDescriptor, alphaToOneEnabled: BOOL) { +RenderPipelineDescriptor_setAlphaToOneEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor, alphaToOneEnabled: BOOL) { msgSend(nil, self, "setAlphaToOneEnabled:", alphaToOneEnabled) } @(objc_type=RenderPipelineDescriptor, objc_name="setBinaryArchives") -RenderPipelineDescriptor_setBinaryArchives :: proc(self: ^RenderPipelineDescriptor, binaryArchives: ^NS.Array) { +RenderPipelineDescriptor_setBinaryArchives :: #force_inline proc(self: ^RenderPipelineDescriptor, binaryArchives: ^NS.Array) { msgSend(nil, self, "setBinaryArchives:", binaryArchives) } @(objc_type=RenderPipelineDescriptor, objc_name="setDepthAttachmentPixelFormat") -RenderPipelineDescriptor_setDepthAttachmentPixelFormat :: proc(self: ^RenderPipelineDescriptor, depthAttachmentPixelFormat: PixelFormat) { +RenderPipelineDescriptor_setDepthAttachmentPixelFormat :: #force_inline proc(self: ^RenderPipelineDescriptor, depthAttachmentPixelFormat: PixelFormat) { msgSend(nil, self, "setDepthAttachmentPixelFormat:", depthAttachmentPixelFormat) } @(objc_type=RenderPipelineDescriptor, objc_name="setFragmentFunction") -RenderPipelineDescriptor_setFragmentFunction :: proc(self: ^RenderPipelineDescriptor, fragmentFunction: ^NS.Object) { +RenderPipelineDescriptor_setFragmentFunction :: #force_inline proc(self: ^RenderPipelineDescriptor, fragmentFunction: ^NS.Object) { msgSend(nil, self, "setFragmentFunction:", fragmentFunction) } @(objc_type=RenderPipelineDescriptor, objc_name="setInputPrimitiveTopology") -RenderPipelineDescriptor_setInputPrimitiveTopology :: proc(self: ^RenderPipelineDescriptor, inputPrimitiveTopology: PrimitiveTopologyClass) { +RenderPipelineDescriptor_setInputPrimitiveTopology :: #force_inline proc(self: ^RenderPipelineDescriptor, inputPrimitiveTopology: PrimitiveTopologyClass) { msgSend(nil, self, "setInputPrimitiveTopology:", inputPrimitiveTopology) } @(objc_type=RenderPipelineDescriptor, objc_name="setLabel") -RenderPipelineDescriptor_setLabel :: proc(self: ^RenderPipelineDescriptor, label: ^NS.String) { +RenderPipelineDescriptor_setLabel :: #force_inline proc(self: ^RenderPipelineDescriptor, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=RenderPipelineDescriptor, objc_name="setMaxTessellationFactor") -RenderPipelineDescriptor_setMaxTessellationFactor :: proc(self: ^RenderPipelineDescriptor, maxTessellationFactor: NS.Integer) { +RenderPipelineDescriptor_setMaxTessellationFactor :: #force_inline proc(self: ^RenderPipelineDescriptor, maxTessellationFactor: NS.Integer) { msgSend(nil, self, "setMaxTessellationFactor:", maxTessellationFactor) } @(objc_type=RenderPipelineDescriptor, objc_name="setMaxVertexAmplificationCount") -RenderPipelineDescriptor_setMaxVertexAmplificationCount :: proc(self: ^RenderPipelineDescriptor, maxVertexAmplificationCount: NS.Integer) { +RenderPipelineDescriptor_setMaxVertexAmplificationCount :: #force_inline proc(self: ^RenderPipelineDescriptor, maxVertexAmplificationCount: NS.Integer) { msgSend(nil, self, "setMaxVertexAmplificationCount:", maxVertexAmplificationCount) } @(objc_type=RenderPipelineDescriptor, objc_name="setRasterSampleCount") -RenderPipelineDescriptor_setRasterSampleCount :: proc(self: ^RenderPipelineDescriptor, rasterSampleCount: NS.Integer) { +RenderPipelineDescriptor_setRasterSampleCount :: #force_inline proc(self: ^RenderPipelineDescriptor, rasterSampleCount: NS.Integer) { msgSend(nil, self, "setRasterSampleCount:", rasterSampleCount) } @(objc_type=RenderPipelineDescriptor, objc_name="setRasterizationEnabled") -RenderPipelineDescriptor_setRasterizationEnabled :: proc(self: ^RenderPipelineDescriptor, rasterizationEnabled: BOOL) { +RenderPipelineDescriptor_setRasterizationEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor, rasterizationEnabled: BOOL) { msgSend(nil, self, "setRasterizationEnabled:", rasterizationEnabled) } @(objc_type=RenderPipelineDescriptor, objc_name="setSampleCount") -RenderPipelineDescriptor_setSampleCount :: proc(self: ^RenderPipelineDescriptor, sampleCount: NS.Integer) { +RenderPipelineDescriptor_setSampleCount :: #force_inline proc(self: ^RenderPipelineDescriptor, sampleCount: NS.Integer) { msgSend(nil, self, "setSampleCount:", sampleCount) } @(objc_type=RenderPipelineDescriptor, objc_name="setStencilAttachmentPixelFormat") -RenderPipelineDescriptor_setStencilAttachmentPixelFormat :: proc(self: ^RenderPipelineDescriptor, stencilAttachmentPixelFormat: PixelFormat) { +RenderPipelineDescriptor_setStencilAttachmentPixelFormat :: #force_inline proc(self: ^RenderPipelineDescriptor, stencilAttachmentPixelFormat: PixelFormat) { msgSend(nil, self, "setStencilAttachmentPixelFormat:", stencilAttachmentPixelFormat) } @(objc_type=RenderPipelineDescriptor, objc_name="setSupportIndirectCommandBuffers") -RenderPipelineDescriptor_setSupportIndirectCommandBuffers :: proc(self: ^RenderPipelineDescriptor, supportIndirectCommandBuffers: BOOL) { +RenderPipelineDescriptor_setSupportIndirectCommandBuffers :: #force_inline proc(self: ^RenderPipelineDescriptor, supportIndirectCommandBuffers: BOOL) { msgSend(nil, self, "setSupportIndirectCommandBuffers:", supportIndirectCommandBuffers) } @(objc_type=RenderPipelineDescriptor, objc_name="setTessellationControlPointIndexType") -RenderPipelineDescriptor_setTessellationControlPointIndexType :: proc(self: ^RenderPipelineDescriptor, tessellationControlPointIndexType: TessellationControlPointIndexType) { +RenderPipelineDescriptor_setTessellationControlPointIndexType :: #force_inline proc(self: ^RenderPipelineDescriptor, tessellationControlPointIndexType: TessellationControlPointIndexType) { msgSend(nil, self, "setTessellationControlPointIndexType:", tessellationControlPointIndexType) } @(objc_type=RenderPipelineDescriptor, objc_name="setTessellationFactorFormat") -RenderPipelineDescriptor_setTessellationFactorFormat :: proc(self: ^RenderPipelineDescriptor, tessellationFactorFormat: TessellationFactorFormat) { +RenderPipelineDescriptor_setTessellationFactorFormat :: #force_inline proc(self: ^RenderPipelineDescriptor, tessellationFactorFormat: TessellationFactorFormat) { msgSend(nil, self, "setTessellationFactorFormat:", tessellationFactorFormat) } @(objc_type=RenderPipelineDescriptor, objc_name="setTessellationFactorScaleEnabled") -RenderPipelineDescriptor_setTessellationFactorScaleEnabled :: proc(self: ^RenderPipelineDescriptor, tessellationFactorScaleEnabled: BOOL) { +RenderPipelineDescriptor_setTessellationFactorScaleEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor, tessellationFactorScaleEnabled: BOOL) { msgSend(nil, self, "setTessellationFactorScaleEnabled:", tessellationFactorScaleEnabled) } @(objc_type=RenderPipelineDescriptor, objc_name="setTessellationFactorStepFunction") -RenderPipelineDescriptor_setTessellationFactorStepFunction :: proc(self: ^RenderPipelineDescriptor, tessellationFactorStepFunction: TessellationFactorStepFunction) { +RenderPipelineDescriptor_setTessellationFactorStepFunction :: #force_inline proc(self: ^RenderPipelineDescriptor, tessellationFactorStepFunction: TessellationFactorStepFunction) { msgSend(nil, self, "setTessellationFactorStepFunction:", tessellationFactorStepFunction) } @(objc_type=RenderPipelineDescriptor, objc_name="setTessellationOutputWindingOrder") -RenderPipelineDescriptor_setTessellationOutputWindingOrder :: proc(self: ^RenderPipelineDescriptor, tessellationOutputWindingOrder: Winding) { +RenderPipelineDescriptor_setTessellationOutputWindingOrder :: #force_inline proc(self: ^RenderPipelineDescriptor, tessellationOutputWindingOrder: Winding) { msgSend(nil, self, "setTessellationOutputWindingOrder:", tessellationOutputWindingOrder) } @(objc_type=RenderPipelineDescriptor, objc_name="setTessellationPartitionMode") -RenderPipelineDescriptor_setTessellationPartitionMode :: proc(self: ^RenderPipelineDescriptor, tessellationPartitionMode: TessellationPartitionMode) { +RenderPipelineDescriptor_setTessellationPartitionMode :: #force_inline proc(self: ^RenderPipelineDescriptor, tessellationPartitionMode: TessellationPartitionMode) { msgSend(nil, self, "setTessellationPartitionMode:", tessellationPartitionMode) } @(objc_type=RenderPipelineDescriptor, objc_name="setVertexDescriptor") -RenderPipelineDescriptor_setVertexDescriptor :: proc(self: ^RenderPipelineDescriptor, vertexDescriptor: ^VertexDescriptor) { +RenderPipelineDescriptor_setVertexDescriptor :: #force_inline proc(self: ^RenderPipelineDescriptor, vertexDescriptor: ^VertexDescriptor) { msgSend(nil, self, "setVertexDescriptor:", vertexDescriptor) } @(objc_type=RenderPipelineDescriptor, objc_name="setVertexFunction") -RenderPipelineDescriptor_setVertexFunction :: proc(self: ^RenderPipelineDescriptor, vertexFunction: ^NS.Object) { +RenderPipelineDescriptor_setVertexFunction :: #force_inline proc(self: ^RenderPipelineDescriptor, vertexFunction: ^NS.Object) { msgSend(nil, self, "setVertexFunction:", vertexFunction) } @(objc_type=RenderPipelineDescriptor, objc_name="stencilAttachmentPixelFormat") -RenderPipelineDescriptor_stencilAttachmentPixelFormat :: proc(self: ^RenderPipelineDescriptor) -> PixelFormat { +RenderPipelineDescriptor_stencilAttachmentPixelFormat :: #force_inline proc(self: ^RenderPipelineDescriptor) -> PixelFormat { return msgSend(PixelFormat, self, "stencilAttachmentPixelFormat") } @(objc_type=RenderPipelineDescriptor, objc_name="supportIndirectCommandBuffers") -RenderPipelineDescriptor_supportIndirectCommandBuffers :: proc(self: ^RenderPipelineDescriptor) -> BOOL { +RenderPipelineDescriptor_supportIndirectCommandBuffers :: #force_inline proc(self: ^RenderPipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "supportIndirectCommandBuffers") } @(objc_type=RenderPipelineDescriptor, objc_name="tessellationControlPointIndexType") -RenderPipelineDescriptor_tessellationControlPointIndexType :: proc(self: ^RenderPipelineDescriptor) -> TessellationControlPointIndexType { +RenderPipelineDescriptor_tessellationControlPointIndexType :: #force_inline proc(self: ^RenderPipelineDescriptor) -> TessellationControlPointIndexType { return msgSend(TessellationControlPointIndexType, self, "tessellationControlPointIndexType") } @(objc_type=RenderPipelineDescriptor, objc_name="tessellationFactorFormat") -RenderPipelineDescriptor_tessellationFactorFormat :: proc(self: ^RenderPipelineDescriptor) -> TessellationFactorFormat { +RenderPipelineDescriptor_tessellationFactorFormat :: #force_inline proc(self: ^RenderPipelineDescriptor) -> TessellationFactorFormat { return msgSend(TessellationFactorFormat, self, "tessellationFactorFormat") } @(objc_type=RenderPipelineDescriptor, objc_name="tessellationFactorStepFunction") -RenderPipelineDescriptor_tessellationFactorStepFunction :: proc(self: ^RenderPipelineDescriptor) -> TessellationFactorStepFunction { +RenderPipelineDescriptor_tessellationFactorStepFunction :: #force_inline proc(self: ^RenderPipelineDescriptor) -> TessellationFactorStepFunction { return msgSend(TessellationFactorStepFunction, self, "tessellationFactorStepFunction") } @(objc_type=RenderPipelineDescriptor, objc_name="tessellationOutputWindingOrder") -RenderPipelineDescriptor_tessellationOutputWindingOrder :: proc(self: ^RenderPipelineDescriptor) -> Winding { +RenderPipelineDescriptor_tessellationOutputWindingOrder :: #force_inline proc(self: ^RenderPipelineDescriptor) -> Winding { return msgSend(Winding, self, "tessellationOutputWindingOrder") } @(objc_type=RenderPipelineDescriptor, objc_name="tessellationPartitionMode") -RenderPipelineDescriptor_tessellationPartitionMode :: proc(self: ^RenderPipelineDescriptor) -> TessellationPartitionMode { +RenderPipelineDescriptor_tessellationPartitionMode :: #force_inline proc(self: ^RenderPipelineDescriptor) -> TessellationPartitionMode { return msgSend(TessellationPartitionMode, self, "tessellationPartitionMode") } @(objc_type=RenderPipelineDescriptor, objc_name="vertexBuffers") -RenderPipelineDescriptor_vertexBuffers :: proc(self: ^RenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray { +RenderPipelineDescriptor_vertexBuffers :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray { return msgSend(^PipelineBufferDescriptorArray, self, "vertexBuffers") } @(objc_type=RenderPipelineDescriptor, objc_name="vertexDescriptor") -RenderPipelineDescriptor_vertexDescriptor :: proc(self: ^RenderPipelineDescriptor) -> ^VertexDescriptor { +RenderPipelineDescriptor_vertexDescriptor :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^VertexDescriptor { return msgSend(^VertexDescriptor, self, "vertexDescriptor") } @(objc_type=RenderPipelineDescriptor, objc_name="vertexFunction") -RenderPipelineDescriptor_vertexFunction :: proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineDescriptor { +RenderPipelineDescriptor_vertexFunction :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineDescriptor { return msgSend(^RenderPipelineDescriptor, self, "vertexFunction") } @@ -3418,23 +3404,23 @@ Methods: RenderPipelineReflection :: struct { using _: NS.Object } @(objc_type=RenderPipelineReflection, objc_class_name="alloc") -RenderPipelineReflection_alloc :: proc() -> ^RenderPipelineReflection { +RenderPipelineReflection_alloc :: #force_inline proc() -> ^RenderPipelineReflection { return msgSend(^RenderPipelineReflection, RenderPipelineReflection, "alloc") } @(objc_type=RenderPipelineReflection, objc_name="init") -RenderPipelineReflection_init :: proc(self: ^RenderPipelineReflection) -> ^RenderPipelineReflection { +RenderPipelineReflection_init :: #force_inline proc(self: ^RenderPipelineReflection) -> ^RenderPipelineReflection { return msgSend(^RenderPipelineReflection, self, "init") } @(objc_type=RenderPipelineReflection, objc_name="fragmentArguments") -RenderPipelineReflection_fragmentArguments :: proc(self: ^RenderPipelineReflection) -> ^NS.Array { +RenderPipelineReflection_fragmentArguments :: #force_inline proc(self: ^RenderPipelineReflection) -> ^NS.Array { return msgSend(^NS.Array, self, "fragmentArguments") } @(objc_type=RenderPipelineReflection, objc_name="tileArguments") -RenderPipelineReflection_tileArguments :: proc(self: ^RenderPipelineReflection) -> ^NS.Array { +RenderPipelineReflection_tileArguments :: #force_inline proc(self: ^RenderPipelineReflection) -> ^NS.Array { return msgSend(^NS.Array, self, "tileArguments") } @(objc_type=RenderPipelineReflection, objc_name="vertexArguments") -RenderPipelineReflection_vertexArguments :: proc(self: ^RenderPipelineReflection) -> ^NS.Array { +RenderPipelineReflection_vertexArguments :: #force_inline proc(self: ^RenderPipelineReflection) -> ^NS.Array { return msgSend(^NS.Array, self, "vertexArguments") } @@ -3454,19 +3440,19 @@ Methods: ResourceStatePassDescriptor :: struct { using _: NS.Copying(ResourceStatePassDescriptor) } @(objc_type=ResourceStatePassDescriptor, objc_class_name="alloc") -ResourceStatePassDescriptor_alloc :: proc() -> ^ResourceStatePassDescriptor { +ResourceStatePassDescriptor_alloc :: #force_inline proc() -> ^ResourceStatePassDescriptor { return msgSend(^ResourceStatePassDescriptor, ResourceStatePassDescriptor, "alloc") } @(objc_type=ResourceStatePassDescriptor, objc_name="init") -ResourceStatePassDescriptor_init :: proc(self: ^ResourceStatePassDescriptor) -> ^ResourceStatePassDescriptor { +ResourceStatePassDescriptor_init :: #force_inline proc(self: ^ResourceStatePassDescriptor) -> ^ResourceStatePassDescriptor { return msgSend(^ResourceStatePassDescriptor, self, "init") } @(objc_type=ResourceStatePassDescriptor, objc_class_name="resourceStatePassDescriptor") -ResourceStatePassDescriptor_resourceStatePassDescriptor :: proc() -> ^ResourceStatePassDescriptor { +ResourceStatePassDescriptor_resourceStatePassDescriptor :: #force_inline proc() -> ^ResourceStatePassDescriptor { return msgSend(^ResourceStatePassDescriptor, ResourceStatePassDescriptor, "resourceStatePassDescriptor") } @(objc_type=ResourceStatePassDescriptor, objc_name="sampleBufferAttachments") -ResourceStatePassDescriptor_sampleBufferAttachments :: proc(self: ^ResourceStatePassDescriptor) -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray { +ResourceStatePassDescriptor_sampleBufferAttachments :: #force_inline proc(self: ^ResourceStatePassDescriptor) -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray { return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptorArray, self, "sampleBufferAttachments") } @@ -3490,35 +3476,35 @@ Methods: ResourceStatePassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(ResourceStatePassSampleBufferAttachmentDescriptor) } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_class_name="alloc") -ResourceStatePassSampleBufferAttachmentDescriptor_alloc :: proc() -> ^ResourceStatePassSampleBufferAttachmentDescriptor { +ResourceStatePassSampleBufferAttachmentDescriptor_alloc :: #force_inline proc() -> ^ResourceStatePassSampleBufferAttachmentDescriptor { return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, ResourceStatePassSampleBufferAttachmentDescriptor, "alloc") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="init") -ResourceStatePassSampleBufferAttachmentDescriptor_init :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> ^ResourceStatePassSampleBufferAttachmentDescriptor { +ResourceStatePassSampleBufferAttachmentDescriptor_init :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> ^ResourceStatePassSampleBufferAttachmentDescriptor { return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, self, "init") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="endOfEncoderSampleIndex") -ResourceStatePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> NS.Integer { +ResourceStatePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "endOfEncoderSampleIndex") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") -ResourceStatePassSampleBufferAttachmentDescriptor_sampleBuffer :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> ^ResourceStatePassSampleBufferAttachmentDescriptor { +ResourceStatePassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> ^ResourceStatePassSampleBufferAttachmentDescriptor { return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, self, "sampleBuffer") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex") -ResourceStatePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.Integer) { +ResourceStatePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.Integer) { msgSend(nil, self, "setEndOfEncoderSampleIndex:", endOfEncoderSampleIndex) } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") -ResourceStatePassSampleBufferAttachmentDescriptor_setSampleBuffer :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) { +ResourceStatePassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) { msgSend(nil, self, "setSampleBuffer:", sampleBuffer) } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="setStartOfEncoderSampleIndex") -ResourceStatePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.Integer) { +ResourceStatePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.Integer) { msgSend(nil, self, "setStartOfEncoderSampleIndex:", startOfEncoderSampleIndex) } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="startOfEncoderSampleIndex") -ResourceStatePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> NS.Integer { +ResourceStatePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "startOfEncoderSampleIndex") } @@ -3538,19 +3524,19 @@ Methods: ResourceStatePassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_class_name="alloc") -ResourceStatePassSampleBufferAttachmentDescriptorArray_alloc :: proc() -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray { +ResourceStatePassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray { return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptorArray, ResourceStatePassSampleBufferAttachmentDescriptorArray, "alloc") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_name="init") -ResourceStatePassSampleBufferAttachmentDescriptorArray_init :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray) -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray { +ResourceStatePassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray) -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray { return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptorArray, self, "init") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -ResourceStatePassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^ResourceStatePassSampleBufferAttachmentDescriptor { +ResourceStatePassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^ResourceStatePassSampleBufferAttachmentDescriptor { return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_name="setObject") -ResourceStatePassSampleBufferAttachmentDescriptorArray_setObject :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray, attachment: ^ResourceStatePassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) { +ResourceStatePassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray, attachment: ^ResourceStatePassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -3598,131 +3584,131 @@ Methods: SamplerDescriptor :: struct { using _: NS.Copying(SamplerDescriptor) } @(objc_type=SamplerDescriptor, objc_class_name="alloc") -SamplerDescriptor_alloc :: proc() -> ^SamplerDescriptor { +SamplerDescriptor_alloc :: #force_inline proc() -> ^SamplerDescriptor { return msgSend(^SamplerDescriptor, SamplerDescriptor, "alloc") } @(objc_type=SamplerDescriptor, objc_name="init") -SamplerDescriptor_init :: proc(self: ^SamplerDescriptor) -> ^SamplerDescriptor { +SamplerDescriptor_init :: #force_inline proc(self: ^SamplerDescriptor) -> ^SamplerDescriptor { return msgSend(^SamplerDescriptor, self, "init") } @(objc_type=SamplerDescriptor, objc_name="borderColor") -SamplerDescriptor_borderColor :: proc(self: ^SamplerDescriptor) -> SamplerBorderColor { +SamplerDescriptor_borderColor :: #force_inline proc(self: ^SamplerDescriptor) -> SamplerBorderColor { return msgSend(SamplerBorderColor, self, "borderColor") } @(objc_type=SamplerDescriptor, objc_name="compareFunction") -SamplerDescriptor_compareFunction :: proc(self: ^SamplerDescriptor) -> CompareFunction { +SamplerDescriptor_compareFunction :: #force_inline proc(self: ^SamplerDescriptor) -> CompareFunction { return msgSend(CompareFunction, self, "compareFunction") } @(objc_type=SamplerDescriptor, objc_name="label") -SamplerDescriptor_label :: proc(self: ^SamplerDescriptor) -> ^NS.String { +SamplerDescriptor_label :: #force_inline proc(self: ^SamplerDescriptor) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=SamplerDescriptor, objc_name="lodAverage") -SamplerDescriptor_lodAverage :: proc(self: ^SamplerDescriptor) -> BOOL { +SamplerDescriptor_lodAverage :: #force_inline proc(self: ^SamplerDescriptor) -> BOOL { return msgSend(BOOL, self, "lodAverage") } @(objc_type=SamplerDescriptor, objc_name="lodMaxClamp") -SamplerDescriptor_lodMaxClamp :: proc(self: ^SamplerDescriptor) -> f32 { +SamplerDescriptor_lodMaxClamp :: #force_inline proc(self: ^SamplerDescriptor) -> f32 { return msgSend(f32, self, "lodMaxClamp") } @(objc_type=SamplerDescriptor, objc_name="lodMinClamp") -SamplerDescriptor_lodMinClamp :: proc(self: ^SamplerDescriptor) -> f32 { +SamplerDescriptor_lodMinClamp :: #force_inline proc(self: ^SamplerDescriptor) -> f32 { return msgSend(f32, self, "lodMinClamp") } @(objc_type=SamplerDescriptor, objc_name="magFilter") -SamplerDescriptor_magFilter :: proc(self: ^SamplerDescriptor) -> SamplerMinMagFilter { +SamplerDescriptor_magFilter :: #force_inline proc(self: ^SamplerDescriptor) -> SamplerMinMagFilter { return msgSend(SamplerMinMagFilter, self, "magFilter") } @(objc_type=SamplerDescriptor, objc_name="maxAnisotropy") -SamplerDescriptor_maxAnisotropy :: proc(self: ^SamplerDescriptor) -> NS.Integer { +SamplerDescriptor_maxAnisotropy :: #force_inline proc(self: ^SamplerDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "maxAnisotropy") } @(objc_type=SamplerDescriptor, objc_name="minFilter") -SamplerDescriptor_minFilter :: proc(self: ^SamplerDescriptor) -> SamplerMinMagFilter { +SamplerDescriptor_minFilter :: #force_inline proc(self: ^SamplerDescriptor) -> SamplerMinMagFilter { return msgSend(SamplerMinMagFilter, self, "minFilter") } @(objc_type=SamplerDescriptor, objc_name="mipFilter") -SamplerDescriptor_mipFilter :: proc(self: ^SamplerDescriptor) -> SamplerMipFilter { +SamplerDescriptor_mipFilter :: #force_inline proc(self: ^SamplerDescriptor) -> SamplerMipFilter { return msgSend(SamplerMipFilter, self, "mipFilter") } @(objc_type=SamplerDescriptor, objc_name="normalizedCoordinates") -SamplerDescriptor_normalizedCoordinates :: proc(self: ^SamplerDescriptor) -> BOOL { +SamplerDescriptor_normalizedCoordinates :: #force_inline proc(self: ^SamplerDescriptor) -> BOOL { return msgSend(BOOL, self, "normalizedCoordinates") } @(objc_type=SamplerDescriptor, objc_name="rAddressMode") -SamplerDescriptor_rAddressMode :: proc(self: ^SamplerDescriptor) -> SamplerAddressMode { +SamplerDescriptor_rAddressMode :: #force_inline proc(self: ^SamplerDescriptor) -> SamplerAddressMode { return msgSend(SamplerAddressMode, self, "rAddressMode") } @(objc_type=SamplerDescriptor, objc_name="sAddressMode") -SamplerDescriptor_sAddressMode :: proc(self: ^SamplerDescriptor) -> SamplerAddressMode { +SamplerDescriptor_sAddressMode :: #force_inline proc(self: ^SamplerDescriptor) -> SamplerAddressMode { return msgSend(SamplerAddressMode, self, "sAddressMode") } @(objc_type=SamplerDescriptor, objc_name="setBorderColor") -SamplerDescriptor_setBorderColor :: proc(self: ^SamplerDescriptor, borderColor: SamplerBorderColor) { +SamplerDescriptor_setBorderColor :: #force_inline proc(self: ^SamplerDescriptor, borderColor: SamplerBorderColor) { msgSend(nil, self, "setBorderColor:", borderColor) } @(objc_type=SamplerDescriptor, objc_name="setCompareFunction") -SamplerDescriptor_setCompareFunction :: proc(self: ^SamplerDescriptor, compareFunction: CompareFunction) { +SamplerDescriptor_setCompareFunction :: #force_inline proc(self: ^SamplerDescriptor, compareFunction: CompareFunction) { msgSend(nil, self, "setCompareFunction:", compareFunction) } @(objc_type=SamplerDescriptor, objc_name="setLabel") -SamplerDescriptor_setLabel :: proc(self: ^SamplerDescriptor, label: ^NS.String) { +SamplerDescriptor_setLabel :: #force_inline proc(self: ^SamplerDescriptor, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=SamplerDescriptor, objc_name="setLodAverage") -SamplerDescriptor_setLodAverage :: proc(self: ^SamplerDescriptor, lodAverage: BOOL) { +SamplerDescriptor_setLodAverage :: #force_inline proc(self: ^SamplerDescriptor, lodAverage: BOOL) { msgSend(nil, self, "setLodAverage:", lodAverage) } @(objc_type=SamplerDescriptor, objc_name="setLodMaxClamp") -SamplerDescriptor_setLodMaxClamp :: proc(self: ^SamplerDescriptor, lodMaxClamp: f32) { +SamplerDescriptor_setLodMaxClamp :: #force_inline proc(self: ^SamplerDescriptor, lodMaxClamp: f32) { msgSend(nil, self, "setLodMaxClamp:", lodMaxClamp) } @(objc_type=SamplerDescriptor, objc_name="setLodMinClamp") -SamplerDescriptor_setLodMinClamp :: proc(self: ^SamplerDescriptor, lodMinClamp: f32) { +SamplerDescriptor_setLodMinClamp :: #force_inline proc(self: ^SamplerDescriptor, lodMinClamp: f32) { msgSend(nil, self, "setLodMinClamp:", lodMinClamp) } @(objc_type=SamplerDescriptor, objc_name="setMagFilter") -SamplerDescriptor_setMagFilter :: proc(self: ^SamplerDescriptor, magFilter: SamplerMinMagFilter) { +SamplerDescriptor_setMagFilter :: #force_inline proc(self: ^SamplerDescriptor, magFilter: SamplerMinMagFilter) { msgSend(nil, self, "setMagFilter:", magFilter) } @(objc_type=SamplerDescriptor, objc_name="setMaxAnisotropy") -SamplerDescriptor_setMaxAnisotropy :: proc(self: ^SamplerDescriptor, maxAnisotropy: NS.Integer) { +SamplerDescriptor_setMaxAnisotropy :: #force_inline proc(self: ^SamplerDescriptor, maxAnisotropy: NS.Integer) { msgSend(nil, self, "setMaxAnisotropy:", maxAnisotropy) } @(objc_type=SamplerDescriptor, objc_name="setMinFilter") -SamplerDescriptor_setMinFilter :: proc(self: ^SamplerDescriptor, minFilter: SamplerMinMagFilter) { +SamplerDescriptor_setMinFilter :: #force_inline proc(self: ^SamplerDescriptor, minFilter: SamplerMinMagFilter) { msgSend(nil, self, "setMinFilter:", minFilter) } @(objc_type=SamplerDescriptor, objc_name="setMipFilter") -SamplerDescriptor_setMipFilter :: proc(self: ^SamplerDescriptor, mipFilter: SamplerMipFilter) { +SamplerDescriptor_setMipFilter :: #force_inline proc(self: ^SamplerDescriptor, mipFilter: SamplerMipFilter) { msgSend(nil, self, "setMipFilter:", mipFilter) } @(objc_type=SamplerDescriptor, objc_name="setNormalizedCoordinates") -SamplerDescriptor_setNormalizedCoordinates :: proc(self: ^SamplerDescriptor, normalizedCoordinates: BOOL) { +SamplerDescriptor_setNormalizedCoordinates :: #force_inline proc(self: ^SamplerDescriptor, normalizedCoordinates: BOOL) { msgSend(nil, self, "setNormalizedCoordinates:", normalizedCoordinates) } @(objc_type=SamplerDescriptor, objc_name="setRAddressMode") -SamplerDescriptor_setRAddressMode :: proc(self: ^SamplerDescriptor, rAddressMode: SamplerAddressMode) { +SamplerDescriptor_setRAddressMode :: #force_inline proc(self: ^SamplerDescriptor, rAddressMode: SamplerAddressMode) { msgSend(nil, self, "setRAddressMode:", rAddressMode) } @(objc_type=SamplerDescriptor, objc_name="setSAddressMode") -SamplerDescriptor_setSAddressMode :: proc(self: ^SamplerDescriptor, sAddressMode: SamplerAddressMode) { +SamplerDescriptor_setSAddressMode :: #force_inline proc(self: ^SamplerDescriptor, sAddressMode: SamplerAddressMode) { msgSend(nil, self, "setSAddressMode:", sAddressMode) } @(objc_type=SamplerDescriptor, objc_name="setSupportArgumentBuffers") -SamplerDescriptor_setSupportArgumentBuffers :: proc(self: ^SamplerDescriptor, supportArgumentBuffers: BOOL) { +SamplerDescriptor_setSupportArgumentBuffers :: #force_inline proc(self: ^SamplerDescriptor, supportArgumentBuffers: BOOL) { msgSend(nil, self, "setSupportArgumentBuffers:", supportArgumentBuffers) } @(objc_type=SamplerDescriptor, objc_name="setTAddressMode") -SamplerDescriptor_setTAddressMode :: proc(self: ^SamplerDescriptor, tAddressMode: SamplerAddressMode) { +SamplerDescriptor_setTAddressMode :: #force_inline proc(self: ^SamplerDescriptor, tAddressMode: SamplerAddressMode) { msgSend(nil, self, "setTAddressMode:", tAddressMode) } @(objc_type=SamplerDescriptor, objc_name="supportArgumentBuffers") -SamplerDescriptor_supportArgumentBuffers :: proc(self: ^SamplerDescriptor) -> BOOL { +SamplerDescriptor_supportArgumentBuffers :: #force_inline proc(self: ^SamplerDescriptor) -> BOOL { return msgSend(BOOL, self, "supportArgumentBuffers") } @(objc_type=SamplerDescriptor, objc_name="tAddressMode") -SamplerDescriptor_tAddressMode :: proc(self: ^SamplerDescriptor) -> SamplerAddressMode { +SamplerDescriptor_tAddressMode :: #force_inline proc(self: ^SamplerDescriptor) -> SamplerAddressMode { return msgSend(SamplerAddressMode, self, "tAddressMode") } @@ -3741,15 +3727,15 @@ Methods: SharedEventHandle :: struct { using _: NS.Object } @(objc_type=SharedEventHandle, objc_class_name="alloc") -SharedEventHandle_alloc :: proc() -> ^SharedEventHandle { +SharedEventHandle_alloc :: #force_inline proc() -> ^SharedEventHandle { return msgSend(^SharedEventHandle, SharedEventHandle, "alloc") } @(objc_type=SharedEventHandle, objc_name="init") -SharedEventHandle_init :: proc(self: ^SharedEventHandle) -> ^SharedEventHandle { +SharedEventHandle_init :: #force_inline proc(self: ^SharedEventHandle) -> ^SharedEventHandle { return msgSend(^SharedEventHandle, self, "init") } @(objc_type=SharedEventHandle, objc_name="label") -SharedEventHandle_label :: proc(self: ^SharedEventHandle) -> ^NS.String { +SharedEventHandle_label :: #force_inline proc(self: ^SharedEventHandle) -> ^NS.String { return msgSend(^NS.String, self, "label") } @@ -3769,19 +3755,19 @@ Methods: SharedEventListener :: struct { using _: NS.Object } @(objc_type=SharedEventListener, objc_class_name="alloc") -SharedEventListener_alloc :: proc() -> ^SharedEventListener { +SharedEventListener_alloc :: #force_inline proc() -> ^SharedEventListener { return msgSend(^SharedEventListener, SharedEventListener, "alloc") } @(objc_type=SharedEventListener, objc_name="dispatchQueue") -SharedEventListener_dispatchQueue :: proc(self: ^SharedEventListener) -> NS.Integer { +SharedEventListener_dispatchQueue :: #force_inline proc(self: ^SharedEventListener) -> NS.Integer { return msgSend(NS.Integer, self, "dispatchQueue") } @(objc_type=SharedEventListener, objc_name="init") -SharedEventListener_init :: proc(self: ^SharedEventListener) -> ^SharedEventListener { +SharedEventListener_init :: #force_inline proc(self: ^SharedEventListener) -> ^SharedEventListener { return msgSend(^SharedEventListener, self, "init") } @(objc_type=SharedEventListener, objc_name="initWithDispatchQueue") -SharedEventListener_initWithDispatchQueue :: proc(self: ^SharedEventListener, dispatchQueue: ^NS.Object) -> ^SharedEventListener { +SharedEventListener_initWithDispatchQueue :: #force_inline proc(self: ^SharedEventListener, dispatchQueue: ^NS.Object) -> ^SharedEventListener { return msgSend(^SharedEventListener, self, "initWithDispatchQueue:", dispatchQueue) } @@ -3801,19 +3787,19 @@ Methods: SharedTextureHandle :: struct { using _: NS.Object } @(objc_type=SharedTextureHandle, objc_class_name="alloc") -SharedTextureHandle_alloc :: proc() -> ^SharedTextureHandle { +SharedTextureHandle_alloc :: #force_inline proc() -> ^SharedTextureHandle { return msgSend(^SharedTextureHandle, SharedTextureHandle, "alloc") } @(objc_type=SharedTextureHandle, objc_name="init") -SharedTextureHandle_init :: proc(self: ^SharedTextureHandle) -> ^SharedTextureHandle { +SharedTextureHandle_init :: #force_inline proc(self: ^SharedTextureHandle) -> ^SharedTextureHandle { return msgSend(^SharedTextureHandle, self, "init") } @(objc_type=SharedTextureHandle, objc_name="device") -SharedTextureHandle_device :: proc(self: ^SharedTextureHandle) -> ^SharedTextureHandle { +SharedTextureHandle_device :: #force_inline proc(self: ^SharedTextureHandle) -> ^SharedTextureHandle { return msgSend(^SharedTextureHandle, self, "device") } @(objc_type=SharedTextureHandle, objc_name="label") -SharedTextureHandle_label :: proc(self: ^SharedTextureHandle) -> ^NS.String { +SharedTextureHandle_label :: #force_inline proc(self: ^SharedTextureHandle) -> ^NS.String { return msgSend(^NS.String, self, "label") } @@ -3839,43 +3825,43 @@ Methods: StageInputOutputDescriptor :: struct { using _: NS.Copying(StageInputOutputDescriptor) } @(objc_type=StageInputOutputDescriptor, objc_class_name="alloc") -StageInputOutputDescriptor_alloc :: proc() -> ^StageInputOutputDescriptor { +StageInputOutputDescriptor_alloc :: #force_inline proc() -> ^StageInputOutputDescriptor { return msgSend(^StageInputOutputDescriptor, StageInputOutputDescriptor, "alloc") } @(objc_type=StageInputOutputDescriptor, objc_name="init") -StageInputOutputDescriptor_init :: proc(self: ^StageInputOutputDescriptor) -> ^StageInputOutputDescriptor { +StageInputOutputDescriptor_init :: #force_inline proc(self: ^StageInputOutputDescriptor) -> ^StageInputOutputDescriptor { return msgSend(^StageInputOutputDescriptor, self, "init") } @(objc_type=StageInputOutputDescriptor, objc_name="attributes") -StageInputOutputDescriptor_attributes :: proc(self: ^StageInputOutputDescriptor) -> ^AttributeDescriptorArray { +StageInputOutputDescriptor_attributes :: #force_inline proc(self: ^StageInputOutputDescriptor) -> ^AttributeDescriptorArray { return msgSend(^AttributeDescriptorArray, self, "attributes") } @(objc_type=StageInputOutputDescriptor, objc_name="indexBufferIndex") -StageInputOutputDescriptor_indexBufferIndex :: proc(self: ^StageInputOutputDescriptor) -> NS.Integer { +StageInputOutputDescriptor_indexBufferIndex :: #force_inline proc(self: ^StageInputOutputDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "indexBufferIndex") } @(objc_type=StageInputOutputDescriptor, objc_name="indexType") -StageInputOutputDescriptor_indexType :: proc(self: ^StageInputOutputDescriptor) -> IndexType { +StageInputOutputDescriptor_indexType :: #force_inline proc(self: ^StageInputOutputDescriptor) -> IndexType { return msgSend(IndexType, self, "indexType") } @(objc_type=StageInputOutputDescriptor, objc_name="layouts") -StageInputOutputDescriptor_layouts :: proc(self: ^StageInputOutputDescriptor) -> ^BufferLayoutDescriptorArray { +StageInputOutputDescriptor_layouts :: #force_inline proc(self: ^StageInputOutputDescriptor) -> ^BufferLayoutDescriptorArray { return msgSend(^BufferLayoutDescriptorArray, self, "layouts") } @(objc_type=StageInputOutputDescriptor, objc_name="reset") -StageInputOutputDescriptor_reset :: proc(self: ^StageInputOutputDescriptor) { +StageInputOutputDescriptor_reset :: #force_inline proc(self: ^StageInputOutputDescriptor) { msgSend(nil, self, "reset") } @(objc_type=StageInputOutputDescriptor, objc_name="setIndexBufferIndex") -StageInputOutputDescriptor_setIndexBufferIndex :: proc(self: ^StageInputOutputDescriptor, indexBufferIndex: NS.Integer) { +StageInputOutputDescriptor_setIndexBufferIndex :: #force_inline proc(self: ^StageInputOutputDescriptor, indexBufferIndex: NS.Integer) { msgSend(nil, self, "setIndexBufferIndex:", indexBufferIndex) } @(objc_type=StageInputOutputDescriptor, objc_name="setIndexType") -StageInputOutputDescriptor_setIndexType :: proc(self: ^StageInputOutputDescriptor, indexType: IndexType) { +StageInputOutputDescriptor_setIndexType :: #force_inline proc(self: ^StageInputOutputDescriptor, indexType: IndexType) { msgSend(nil, self, "setIndexType:", indexType) } @(objc_type=StageInputOutputDescriptor, objc_class_name="stageInputOutputDescriptor") -StageInputOutputDescriptor_stageInputOutputDescriptor :: proc() -> ^StageInputOutputDescriptor { +StageInputOutputDescriptor_stageInputOutputDescriptor :: #force_inline proc() -> ^StageInputOutputDescriptor { return msgSend(^StageInputOutputDescriptor, StageInputOutputDescriptor, "stageInputOutputDescriptor") } @@ -3905,59 +3891,59 @@ Methods: StencilDescriptor :: struct { using _: NS.Copying(StencilDescriptor) } @(objc_type=StencilDescriptor, objc_class_name="alloc") -StencilDescriptor_alloc :: proc() -> ^StencilDescriptor { +StencilDescriptor_alloc :: #force_inline proc() -> ^StencilDescriptor { return msgSend(^StencilDescriptor, StencilDescriptor, "alloc") } @(objc_type=StencilDescriptor, objc_name="init") -StencilDescriptor_init :: proc(self: ^StencilDescriptor) -> ^StencilDescriptor { +StencilDescriptor_init :: #force_inline proc(self: ^StencilDescriptor) -> ^StencilDescriptor { return msgSend(^StencilDescriptor, self, "init") } @(objc_type=StencilDescriptor, objc_name="depthFailureOperation") -StencilDescriptor_depthFailureOperation :: proc(self: ^StencilDescriptor) -> StencilOperation { +StencilDescriptor_depthFailureOperation :: #force_inline proc(self: ^StencilDescriptor) -> StencilOperation { return msgSend(StencilOperation, self, "depthFailureOperation") } @(objc_type=StencilDescriptor, objc_name="depthStencilPassOperation") -StencilDescriptor_depthStencilPassOperation :: proc(self: ^StencilDescriptor) -> StencilOperation { +StencilDescriptor_depthStencilPassOperation :: #force_inline proc(self: ^StencilDescriptor) -> StencilOperation { return msgSend(StencilOperation, self, "depthStencilPassOperation") } @(objc_type=StencilDescriptor, objc_name="readMask") -StencilDescriptor_readMask :: proc(self: ^StencilDescriptor) -> u32 { +StencilDescriptor_readMask :: #force_inline proc(self: ^StencilDescriptor) -> u32 { return msgSend(u32, self, "readMask") } @(objc_type=StencilDescriptor, objc_name="setDepthFailureOperation") -StencilDescriptor_setDepthFailureOperation :: proc(self: ^StencilDescriptor, depthFailureOperation: StencilOperation) { +StencilDescriptor_setDepthFailureOperation :: #force_inline proc(self: ^StencilDescriptor, depthFailureOperation: StencilOperation) { msgSend(nil, self, "setDepthFailureOperation:", depthFailureOperation) } @(objc_type=StencilDescriptor, objc_name="setDepthStencilPassOperation") -StencilDescriptor_setDepthStencilPassOperation :: proc(self: ^StencilDescriptor, depthStencilPassOperation: StencilOperation) { +StencilDescriptor_setDepthStencilPassOperation :: #force_inline proc(self: ^StencilDescriptor, depthStencilPassOperation: StencilOperation) { msgSend(nil, self, "setDepthStencilPassOperation:", depthStencilPassOperation) } @(objc_type=StencilDescriptor, objc_name="setReadMask") -StencilDescriptor_setReadMask :: proc(self: ^StencilDescriptor, readMask: u32) { +StencilDescriptor_setReadMask :: #force_inline proc(self: ^StencilDescriptor, readMask: u32) { msgSend(nil, self, "setReadMask:", readMask) } @(objc_type=StencilDescriptor, objc_name="setStencilCompareFunction") -StencilDescriptor_setStencilCompareFunction :: proc(self: ^StencilDescriptor, stencilCompareFunction: CompareFunction) { +StencilDescriptor_setStencilCompareFunction :: #force_inline proc(self: ^StencilDescriptor, stencilCompareFunction: CompareFunction) { msgSend(nil, self, "setStencilCompareFunction:", stencilCompareFunction) } @(objc_type=StencilDescriptor, objc_name="setStencilFailureOperation") -StencilDescriptor_setStencilFailureOperation :: proc(self: ^StencilDescriptor, stencilFailureOperation: StencilOperation) { +StencilDescriptor_setStencilFailureOperation :: #force_inline proc(self: ^StencilDescriptor, stencilFailureOperation: StencilOperation) { msgSend(nil, self, "setStencilFailureOperation:", stencilFailureOperation) } @(objc_type=StencilDescriptor, objc_name="setWriteMask") -StencilDescriptor_setWriteMask :: proc(self: ^StencilDescriptor, writeMask: u32) { +StencilDescriptor_setWriteMask :: #force_inline proc(self: ^StencilDescriptor, writeMask: u32) { msgSend(nil, self, "setWriteMask:", writeMask) } @(objc_type=StencilDescriptor, objc_name="stencilCompareFunction") -StencilDescriptor_stencilCompareFunction :: proc(self: ^StencilDescriptor) -> CompareFunction { +StencilDescriptor_stencilCompareFunction :: #force_inline proc(self: ^StencilDescriptor) -> CompareFunction { return msgSend(CompareFunction, self, "stencilCompareFunction") } @(objc_type=StencilDescriptor, objc_name="stencilFailureOperation") -StencilDescriptor_stencilFailureOperation :: proc(self: ^StencilDescriptor) -> StencilOperation { +StencilDescriptor_stencilFailureOperation :: #force_inline proc(self: ^StencilDescriptor) -> StencilOperation { return msgSend(StencilOperation, self, "stencilFailureOperation") } @(objc_type=StencilDescriptor, objc_name="writeMask") -StencilDescriptor_writeMask :: proc(self: ^StencilDescriptor) -> u32 { +StencilDescriptor_writeMask :: #force_inline proc(self: ^StencilDescriptor) -> u32 { return msgSend(u32, self, "writeMask") } @@ -3983,43 +3969,43 @@ Methods: StructMember :: struct { using _: NS.Object } @(objc_type=StructMember, objc_class_name="alloc") -StructMember_alloc :: proc() -> ^StructMember { +StructMember_alloc :: #force_inline proc() -> ^StructMember { return msgSend(^StructMember, StructMember, "alloc") } @(objc_type=StructMember, objc_name="init") -StructMember_init :: proc(self: ^StructMember) -> ^StructMember { +StructMember_init :: #force_inline proc(self: ^StructMember) -> ^StructMember { return msgSend(^StructMember, self, "init") } @(objc_type=StructMember, objc_name="argumentIndex") -StructMember_argumentIndex :: proc(self: ^StructMember) -> NS.Integer { +StructMember_argumentIndex :: #force_inline proc(self: ^StructMember) -> NS.Integer { return msgSend(NS.Integer, self, "argumentIndex") } @(objc_type=StructMember, objc_name="arrayType") -StructMember_arrayType :: proc(self: ^StructMember) -> ^ArrayType { +StructMember_arrayType :: #force_inline proc(self: ^StructMember) -> ^ArrayType { return msgSend(^ArrayType, self, "arrayType") } @(objc_type=StructMember, objc_name="dataType") -StructMember_dataType :: proc(self: ^StructMember) -> DataType { +StructMember_dataType :: #force_inline proc(self: ^StructMember) -> DataType { return msgSend(DataType, self, "dataType") } @(objc_type=StructMember, objc_name="name") -StructMember_name :: proc(self: ^StructMember) -> ^NS.String { +StructMember_name :: #force_inline proc(self: ^StructMember) -> ^NS.String { return msgSend(^NS.String, self, "name") } @(objc_type=StructMember, objc_name="offset") -StructMember_offset :: proc(self: ^StructMember) -> NS.Integer { +StructMember_offset :: #force_inline proc(self: ^StructMember) -> NS.Integer { return msgSend(NS.Integer, self, "offset") } @(objc_type=StructMember, objc_name="pointerType") -StructMember_pointerType :: proc(self: ^StructMember) -> ^PointerType { +StructMember_pointerType :: #force_inline proc(self: ^StructMember) -> ^PointerType { return msgSend(^PointerType, self, "pointerType") } @(objc_type=StructMember, objc_name="structType") -StructMember_structType :: proc(self: ^StructMember) -> ^StructType { +StructMember_structType :: #force_inline proc(self: ^StructMember) -> ^StructType { return msgSend(^StructType, self, "structType") } @(objc_type=StructMember, objc_name="textureReferenceType") -StructMember_textureReferenceType :: proc(self: ^StructMember) -> ^TextureReferenceType { +StructMember_textureReferenceType :: #force_inline proc(self: ^StructMember) -> ^TextureReferenceType { return msgSend(^TextureReferenceType, self, "textureReferenceType") } @@ -4039,19 +4025,19 @@ Methods: StructType :: struct { using _: NS.Object } @(objc_type=StructType, objc_class_name="alloc") -StructType_alloc :: proc() -> ^StructType { +StructType_alloc :: #force_inline proc() -> ^StructType { return msgSend(^StructType, StructType, "alloc") } @(objc_type=StructType, objc_name="init") -StructType_init :: proc(self: ^StructType) -> ^StructType { +StructType_init :: #force_inline proc(self: ^StructType) -> ^StructType { return msgSend(^StructType, self, "init") } @(objc_type=StructType, objc_name="memberByName") -StructType_memberByName :: proc(self: ^StructType, name: ^NS.String) -> ^StructMember { +StructType_memberByName :: #force_inline proc(self: ^StructType, name: ^NS.String) -> ^StructMember { return msgSend(^StructMember, self, "memberByName:", name) } @(objc_type=StructType, objc_name="members") -StructType_members :: proc(self: ^StructType) -> ^NS.Array { +StructType_members :: #force_inline proc(self: ^StructType) -> ^NS.Array { return msgSend(^NS.Array, self, "members") } @@ -4102,143 +4088,143 @@ Methods: TextureDescriptor :: struct { using _: NS.Copying(TextureDescriptor) } @(objc_type=TextureDescriptor, objc_class_name="alloc") -TextureDescriptor_alloc :: proc() -> ^TextureDescriptor { +TextureDescriptor_alloc :: #force_inline proc() -> ^TextureDescriptor { return msgSend(^TextureDescriptor, TextureDescriptor, "alloc") } @(objc_type=TextureDescriptor, objc_name="init") -TextureDescriptor_init :: proc(self: ^TextureDescriptor) -> ^TextureDescriptor { +TextureDescriptor_init :: #force_inline proc(self: ^TextureDescriptor) -> ^TextureDescriptor { return msgSend(^TextureDescriptor, self, "init") } @(objc_type=TextureDescriptor, objc_name="allowGPUOptimizedContents") -TextureDescriptor_allowGPUOptimizedContents :: proc(self: ^TextureDescriptor) -> BOOL { +TextureDescriptor_allowGPUOptimizedContents :: #force_inline proc(self: ^TextureDescriptor) -> BOOL { return msgSend(BOOL, self, "allowGPUOptimizedContents") } @(objc_type=TextureDescriptor, objc_name="arrayLength") -TextureDescriptor_arrayLength :: proc(self: ^TextureDescriptor) -> NS.Integer { +TextureDescriptor_arrayLength :: #force_inline proc(self: ^TextureDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "arrayLength") } @(objc_type=TextureDescriptor, objc_name="cpuCacheMode") -TextureDescriptor_cpuCacheMode :: proc(self: ^TextureDescriptor) -> CPUCacheMode { +TextureDescriptor_cpuCacheMode :: #force_inline proc(self: ^TextureDescriptor) -> CPUCacheMode { return msgSend(CPUCacheMode, self, "cpuCacheMode") } @(objc_type=TextureDescriptor, objc_name="depth") -TextureDescriptor_depth :: proc(self: ^TextureDescriptor) -> NS.Integer { +TextureDescriptor_depth :: #force_inline proc(self: ^TextureDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "depth") } @(objc_type=TextureDescriptor, objc_name="hazardTrackingMode") -TextureDescriptor_hazardTrackingMode :: proc(self: ^TextureDescriptor) -> HazardTrackingMode { +TextureDescriptor_hazardTrackingMode :: #force_inline proc(self: ^TextureDescriptor) -> HazardTrackingMode { return msgSend(HazardTrackingMode, self, "hazardTrackingMode") } @(objc_type=TextureDescriptor, objc_name="height") -TextureDescriptor_height :: proc(self: ^TextureDescriptor) -> NS.Integer { +TextureDescriptor_height :: #force_inline proc(self: ^TextureDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "height") } @(objc_type=TextureDescriptor, objc_name="mipmapLevelCount") -TextureDescriptor_mipmapLevelCount :: proc(self: ^TextureDescriptor) -> NS.Integer { +TextureDescriptor_mipmapLevelCount :: #force_inline proc(self: ^TextureDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "mipmapLevelCount") } @(objc_type=TextureDescriptor, objc_name="pixelFormat") -TextureDescriptor_pixelFormat :: proc(self: ^TextureDescriptor) -> PixelFormat { +TextureDescriptor_pixelFormat :: #force_inline proc(self: ^TextureDescriptor) -> PixelFormat { return msgSend(PixelFormat, self, "pixelFormat") } @(objc_type=TextureDescriptor, objc_name="resourceOptions") -TextureDescriptor_resourceOptions :: proc(self: ^TextureDescriptor) -> ResourceOptions { +TextureDescriptor_resourceOptions :: #force_inline proc(self: ^TextureDescriptor) -> ResourceOptions { return msgSend(ResourceOptions, self, "resourceOptions") } @(objc_type=TextureDescriptor, objc_name="sampleCount") -TextureDescriptor_sampleCount :: proc(self: ^TextureDescriptor) -> NS.Integer { +TextureDescriptor_sampleCount :: #force_inline proc(self: ^TextureDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "sampleCount") } @(objc_type=TextureDescriptor, objc_name="setAllowGPUOptimizedContents") -TextureDescriptor_setAllowGPUOptimizedContents :: proc(self: ^TextureDescriptor, allowGPUOptimizedContents: BOOL) { +TextureDescriptor_setAllowGPUOptimizedContents :: #force_inline proc(self: ^TextureDescriptor, allowGPUOptimizedContents: BOOL) { msgSend(nil, self, "setAllowGPUOptimizedContents:", allowGPUOptimizedContents) } @(objc_type=TextureDescriptor, objc_name="setArrayLength") -TextureDescriptor_setArrayLength :: proc(self: ^TextureDescriptor, arrayLength: NS.Integer) { +TextureDescriptor_setArrayLength :: #force_inline proc(self: ^TextureDescriptor, arrayLength: NS.Integer) { msgSend(nil, self, "setArrayLength:", arrayLength) } @(objc_type=TextureDescriptor, objc_name="setCpuCacheMode") -TextureDescriptor_setCpuCacheMode :: proc(self: ^TextureDescriptor, cpuCacheMode: CPUCacheMode) { +TextureDescriptor_setCpuCacheMode :: #force_inline proc(self: ^TextureDescriptor, cpuCacheMode: CPUCacheMode) { msgSend(nil, self, "setCpuCacheMode:", cpuCacheMode) } @(objc_type=TextureDescriptor, objc_name="setDepth") -TextureDescriptor_setDepth :: proc(self: ^TextureDescriptor, depth: NS.Integer) { +TextureDescriptor_setDepth :: #force_inline proc(self: ^TextureDescriptor, depth: NS.Integer) { msgSend(nil, self, "setDepth:", depth) } @(objc_type=TextureDescriptor, objc_name="setHazardTrackingMode") -TextureDescriptor_setHazardTrackingMode :: proc(self: ^TextureDescriptor, hazardTrackingMode: HazardTrackingMode) { +TextureDescriptor_setHazardTrackingMode :: #force_inline proc(self: ^TextureDescriptor, hazardTrackingMode: HazardTrackingMode) { msgSend(nil, self, "setHazardTrackingMode:", hazardTrackingMode) } @(objc_type=TextureDescriptor, objc_name="setHeight") -TextureDescriptor_setHeight :: proc(self: ^TextureDescriptor, height: NS.Integer) { +TextureDescriptor_setHeight :: #force_inline proc(self: ^TextureDescriptor, height: NS.Integer) { msgSend(nil, self, "setHeight:", height) } @(objc_type=TextureDescriptor, objc_name="setMipmapLevelCount") -TextureDescriptor_setMipmapLevelCount :: proc(self: ^TextureDescriptor, mipmapLevelCount: NS.Integer) { +TextureDescriptor_setMipmapLevelCount :: #force_inline proc(self: ^TextureDescriptor, mipmapLevelCount: NS.Integer) { msgSend(nil, self, "setMipmapLevelCount:", mipmapLevelCount) } @(objc_type=TextureDescriptor, objc_name="setPixelFormat") -TextureDescriptor_setPixelFormat :: proc(self: ^TextureDescriptor, pixelFormat: PixelFormat) { +TextureDescriptor_setPixelFormat :: #force_inline proc(self: ^TextureDescriptor, pixelFormat: PixelFormat) { msgSend(nil, self, "setPixelFormat:", pixelFormat) } @(objc_type=TextureDescriptor, objc_name="setResourceOptions") -TextureDescriptor_setResourceOptions :: proc(self: ^TextureDescriptor, resourceOptions: ResourceOptions) { +TextureDescriptor_setResourceOptions :: #force_inline proc(self: ^TextureDescriptor, resourceOptions: ResourceOptions) { msgSend(nil, self, "setResourceOptions:", resourceOptions) } @(objc_type=TextureDescriptor, objc_name="setSampleCount") -TextureDescriptor_setSampleCount :: proc(self: ^TextureDescriptor, sampleCount: NS.Integer) { +TextureDescriptor_setSampleCount :: #force_inline proc(self: ^TextureDescriptor, sampleCount: NS.Integer) { msgSend(nil, self, "setSampleCount:", sampleCount) } @(objc_type=TextureDescriptor, objc_name="setStorageMode") -TextureDescriptor_setStorageMode :: proc(self: ^TextureDescriptor, storageMode: StorageMode) { +TextureDescriptor_setStorageMode :: #force_inline proc(self: ^TextureDescriptor, storageMode: StorageMode) { msgSend(nil, self, "setStorageMode:", storageMode) } @(objc_type=TextureDescriptor, objc_name="setSwizzle") -TextureDescriptor_setSwizzle :: proc(self: ^TextureDescriptor, swizzle: TextureSwizzleChannels) { +TextureDescriptor_setSwizzle :: #force_inline proc(self: ^TextureDescriptor, swizzle: TextureSwizzleChannels) { msgSend(nil, self, "setSwizzle:", swizzle) } @(objc_type=TextureDescriptor, objc_name="setTextureType") -TextureDescriptor_setTextureType :: proc(self: ^TextureDescriptor, textureType: TextureType) { +TextureDescriptor_setTextureType :: #force_inline proc(self: ^TextureDescriptor, textureType: TextureType) { msgSend(nil, self, "setTextureType:", textureType) } @(objc_type=TextureDescriptor, objc_name="setUsage") -TextureDescriptor_setUsage :: proc(self: ^TextureDescriptor, usage: TextureUsage) { +TextureDescriptor_setUsage :: #force_inline proc(self: ^TextureDescriptor, usage: TextureUsage) { msgSend(nil, self, "setUsage:", usage) } @(objc_type=TextureDescriptor, objc_name="setWidth") -TextureDescriptor_setWidth :: proc(self: ^TextureDescriptor, width: NS.Integer) { +TextureDescriptor_setWidth :: #force_inline proc(self: ^TextureDescriptor, width: NS.Integer) { msgSend(nil, self, "setWidth:", width) } @(objc_type=TextureDescriptor, objc_name="storageMode") -TextureDescriptor_storageMode :: proc(self: ^TextureDescriptor) -> StorageMode { +TextureDescriptor_storageMode :: #force_inline proc(self: ^TextureDescriptor) -> StorageMode { return msgSend(StorageMode, self, "storageMode") } @(objc_type=TextureDescriptor, objc_name="swizzle") -TextureDescriptor_swizzle :: proc(self: ^TextureDescriptor) -> TextureSwizzleChannels { +TextureDescriptor_swizzle :: #force_inline proc(self: ^TextureDescriptor) -> TextureSwizzleChannels { return msgSend(TextureSwizzleChannels, self, "swizzle") } @(objc_type=TextureDescriptor, objc_class_name="texture2DDescriptorWithPixelFormat") -TextureDescriptor_texture2DDescriptorWithPixelFormat :: proc(pixelFormat: PixelFormat, width: ^NS.Object, height: ^NS.Object, mipmapped: BOOL) -> ^TextureDescriptor { +TextureDescriptor_texture2DDescriptorWithPixelFormat :: #force_inline proc(pixelFormat: PixelFormat, width: ^NS.Object, height: ^NS.Object, mipmapped: BOOL) -> ^TextureDescriptor { return msgSend(^TextureDescriptor, TextureDescriptor, "texture2DDescriptorWithPixelFormat:width:height:mipmapped:", pixelFormat, width, height, mipmapped) } @(objc_type=TextureDescriptor, objc_class_name="textureBufferDescriptorWithPixelFormat") -TextureDescriptor_textureBufferDescriptorWithPixelFormat :: proc(pixelFormat: PixelFormat, width: ^NS.Object, resourceOptions: ResourceOptions, usage: TextureUsage) -> ^TextureDescriptor { +TextureDescriptor_textureBufferDescriptorWithPixelFormat :: #force_inline proc(pixelFormat: PixelFormat, width: ^NS.Object, resourceOptions: ResourceOptions, usage: TextureUsage) -> ^TextureDescriptor { return msgSend(^TextureDescriptor, TextureDescriptor, "textureBufferDescriptorWithPixelFormat:width:resourceOptions:usage:", pixelFormat, width, resourceOptions, usage) } @(objc_type=TextureDescriptor, objc_class_name="textureCubeDescriptorWithPixelFormat") -TextureDescriptor_textureCubeDescriptorWithPixelFormat :: proc(pixelFormat: PixelFormat, size: ^NS.Object, mipmapped: BOOL) -> ^TextureDescriptor { +TextureDescriptor_textureCubeDescriptorWithPixelFormat :: #force_inline proc(pixelFormat: PixelFormat, size: ^NS.Object, mipmapped: BOOL) -> ^TextureDescriptor { return msgSend(^TextureDescriptor, TextureDescriptor, "textureCubeDescriptorWithPixelFormat:size:mipmapped:", pixelFormat, size, mipmapped) } @(objc_type=TextureDescriptor, objc_name="textureType") -TextureDescriptor_textureType :: proc(self: ^TextureDescriptor) -> TextureType { +TextureDescriptor_textureType :: #force_inline proc(self: ^TextureDescriptor) -> TextureType { return msgSend(TextureType, self, "textureType") } @(objc_type=TextureDescriptor, objc_name="usage") -TextureDescriptor_usage :: proc(self: ^TextureDescriptor) -> TextureUsage { +TextureDescriptor_usage :: #force_inline proc(self: ^TextureDescriptor) -> TextureUsage { return msgSend(TextureUsage, self, "usage") } @(objc_type=TextureDescriptor, objc_name="width") -TextureDescriptor_width :: proc(self: ^TextureDescriptor) -> NS.Integer { +TextureDescriptor_width :: #force_inline proc(self: ^TextureDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "width") } @@ -4260,27 +4246,27 @@ Methods: TextureReferenceType :: struct { using _: NS.Object } @(objc_type=TextureReferenceType, objc_class_name="alloc") -TextureReferenceType_alloc :: proc() -> ^TextureReferenceType { +TextureReferenceType_alloc :: #force_inline proc() -> ^TextureReferenceType { return msgSend(^TextureReferenceType, TextureReferenceType, "alloc") } @(objc_type=TextureReferenceType, objc_name="init") -TextureReferenceType_init :: proc(self: ^TextureReferenceType) -> ^TextureReferenceType { +TextureReferenceType_init :: #force_inline proc(self: ^TextureReferenceType) -> ^TextureReferenceType { return msgSend(^TextureReferenceType, self, "init") } @(objc_type=TextureReferenceType, objc_name="access") -TextureReferenceType_access :: proc(self: ^TextureReferenceType) -> ArgumentAccess { +TextureReferenceType_access :: #force_inline proc(self: ^TextureReferenceType) -> ArgumentAccess { return msgSend(ArgumentAccess, self, "access") } @(objc_type=TextureReferenceType, objc_name="isDepthTexture") -TextureReferenceType_isDepthTexture :: proc(self: ^TextureReferenceType) -> BOOL { +TextureReferenceType_isDepthTexture :: #force_inline proc(self: ^TextureReferenceType) -> BOOL { return msgSend(BOOL, self, "isDepthTexture") } @(objc_type=TextureReferenceType, objc_name="textureDataType") -TextureReferenceType_textureDataType :: proc(self: ^TextureReferenceType) -> DataType { +TextureReferenceType_textureDataType :: #force_inline proc(self: ^TextureReferenceType) -> DataType { return msgSend(DataType, self, "textureDataType") } @(objc_type=TextureReferenceType, objc_name="textureType") -TextureReferenceType_textureType :: proc(self: ^TextureReferenceType) -> TextureType { +TextureReferenceType_textureType :: #force_inline proc(self: ^TextureReferenceType) -> TextureType { return msgSend(TextureType, self, "textureType") } @@ -4300,19 +4286,19 @@ Methods: TileRenderPipelineColorAttachmentDescriptor :: struct { using _: NS.Copying(TileRenderPipelineColorAttachmentDescriptor) } @(objc_type=TileRenderPipelineColorAttachmentDescriptor, objc_class_name="alloc") -TileRenderPipelineColorAttachmentDescriptor_alloc :: proc() -> ^TileRenderPipelineColorAttachmentDescriptor { +TileRenderPipelineColorAttachmentDescriptor_alloc :: #force_inline proc() -> ^TileRenderPipelineColorAttachmentDescriptor { return msgSend(^TileRenderPipelineColorAttachmentDescriptor, TileRenderPipelineColorAttachmentDescriptor, "alloc") } @(objc_type=TileRenderPipelineColorAttachmentDescriptor, objc_name="init") -TileRenderPipelineColorAttachmentDescriptor_init :: proc(self: ^TileRenderPipelineColorAttachmentDescriptor) -> ^TileRenderPipelineColorAttachmentDescriptor { +TileRenderPipelineColorAttachmentDescriptor_init :: #force_inline proc(self: ^TileRenderPipelineColorAttachmentDescriptor) -> ^TileRenderPipelineColorAttachmentDescriptor { return msgSend(^TileRenderPipelineColorAttachmentDescriptor, self, "init") } @(objc_type=TileRenderPipelineColorAttachmentDescriptor, objc_name="pixelFormat") -TileRenderPipelineColorAttachmentDescriptor_pixelFormat :: proc(self: ^TileRenderPipelineColorAttachmentDescriptor) -> PixelFormat { +TileRenderPipelineColorAttachmentDescriptor_pixelFormat :: #force_inline proc(self: ^TileRenderPipelineColorAttachmentDescriptor) -> PixelFormat { return msgSend(PixelFormat, self, "pixelFormat") } @(objc_type=TileRenderPipelineColorAttachmentDescriptor, objc_name="setPixelFormat") -TileRenderPipelineColorAttachmentDescriptor_setPixelFormat :: proc(self: ^TileRenderPipelineColorAttachmentDescriptor, pixelFormat: PixelFormat) { +TileRenderPipelineColorAttachmentDescriptor_setPixelFormat :: #force_inline proc(self: ^TileRenderPipelineColorAttachmentDescriptor, pixelFormat: PixelFormat) { msgSend(nil, self, "setPixelFormat:", pixelFormat) } @@ -4332,19 +4318,19 @@ Methods: TileRenderPipelineColorAttachmentDescriptorArray :: struct { using _: NS.Object } @(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_class_name="alloc") -TileRenderPipelineColorAttachmentDescriptorArray_alloc :: proc() -> ^TileRenderPipelineColorAttachmentDescriptorArray { +TileRenderPipelineColorAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^TileRenderPipelineColorAttachmentDescriptorArray { return msgSend(^TileRenderPipelineColorAttachmentDescriptorArray, TileRenderPipelineColorAttachmentDescriptorArray, "alloc") } @(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_name="init") -TileRenderPipelineColorAttachmentDescriptorArray_init :: proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray) -> ^TileRenderPipelineColorAttachmentDescriptorArray { +TileRenderPipelineColorAttachmentDescriptorArray_init :: #force_inline proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray) -> ^TileRenderPipelineColorAttachmentDescriptorArray { return msgSend(^TileRenderPipelineColorAttachmentDescriptorArray, self, "init") } @(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -TileRenderPipelineColorAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^TileRenderPipelineColorAttachmentDescriptor { +TileRenderPipelineColorAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^TileRenderPipelineColorAttachmentDescriptor { return msgSend(^TileRenderPipelineColorAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_name="setObject") -TileRenderPipelineColorAttachmentDescriptorArray_setObject :: proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray, attachment: ^TileRenderPipelineColorAttachmentDescriptor, attachmentIndex: ^NS.Object) { +TileRenderPipelineColorAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray, attachment: ^TileRenderPipelineColorAttachmentDescriptor, attachmentIndex: ^NS.Object) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -4377,71 +4363,71 @@ Methods: TileRenderPipelineDescriptor :: struct { using _: NS.Copying(TileRenderPipelineDescriptor) } @(objc_type=TileRenderPipelineDescriptor, objc_class_name="alloc") -TileRenderPipelineDescriptor_alloc :: proc() -> ^TileRenderPipelineDescriptor { +TileRenderPipelineDescriptor_alloc :: #force_inline proc() -> ^TileRenderPipelineDescriptor { return msgSend(^TileRenderPipelineDescriptor, TileRenderPipelineDescriptor, "alloc") } @(objc_type=TileRenderPipelineDescriptor, objc_name="init") -TileRenderPipelineDescriptor_init :: proc(self: ^TileRenderPipelineDescriptor) -> ^TileRenderPipelineDescriptor { +TileRenderPipelineDescriptor_init :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> ^TileRenderPipelineDescriptor { return msgSend(^TileRenderPipelineDescriptor, self, "init") } @(objc_type=TileRenderPipelineDescriptor, objc_name="binaryArchives") -TileRenderPipelineDescriptor_binaryArchives :: proc(self: ^TileRenderPipelineDescriptor) -> ^NS.Array { +TileRenderPipelineDescriptor_binaryArchives :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> ^NS.Array { return msgSend(^NS.Array, self, "binaryArchives") } @(objc_type=TileRenderPipelineDescriptor, objc_name="colorAttachments") -TileRenderPipelineDescriptor_colorAttachments :: proc(self: ^TileRenderPipelineDescriptor) -> ^TileRenderPipelineColorAttachmentDescriptorArray { +TileRenderPipelineDescriptor_colorAttachments :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> ^TileRenderPipelineColorAttachmentDescriptorArray { return msgSend(^TileRenderPipelineColorAttachmentDescriptorArray, self, "colorAttachments") } @(objc_type=TileRenderPipelineDescriptor, objc_name="label") -TileRenderPipelineDescriptor_label :: proc(self: ^TileRenderPipelineDescriptor) -> ^NS.String { +TileRenderPipelineDescriptor_label :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=TileRenderPipelineDescriptor, objc_name="maxTotalThreadsPerThreadgroup") -TileRenderPipelineDescriptor_maxTotalThreadsPerThreadgroup :: proc(self: ^TileRenderPipelineDescriptor) -> NS.Integer { +TileRenderPipelineDescriptor_maxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "maxTotalThreadsPerThreadgroup") } @(objc_type=TileRenderPipelineDescriptor, objc_name="rasterSampleCount") -TileRenderPipelineDescriptor_rasterSampleCount :: proc(self: ^TileRenderPipelineDescriptor) -> NS.Integer { +TileRenderPipelineDescriptor_rasterSampleCount :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "rasterSampleCount") } @(objc_type=TileRenderPipelineDescriptor, objc_name="reset") -TileRenderPipelineDescriptor_reset :: proc(self: ^TileRenderPipelineDescriptor) { +TileRenderPipelineDescriptor_reset :: #force_inline proc(self: ^TileRenderPipelineDescriptor) { msgSend(nil, self, "reset") } @(objc_type=TileRenderPipelineDescriptor, objc_name="setBinaryArchives") -TileRenderPipelineDescriptor_setBinaryArchives :: proc(self: ^TileRenderPipelineDescriptor, binaryArchives: ^NS.Array) { +TileRenderPipelineDescriptor_setBinaryArchives :: #force_inline proc(self: ^TileRenderPipelineDescriptor, binaryArchives: ^NS.Array) { msgSend(nil, self, "setBinaryArchives:", binaryArchives) } @(objc_type=TileRenderPipelineDescriptor, objc_name="setLabel") -TileRenderPipelineDescriptor_setLabel :: proc(self: ^TileRenderPipelineDescriptor, label: ^NS.String) { +TileRenderPipelineDescriptor_setLabel :: #force_inline proc(self: ^TileRenderPipelineDescriptor, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=TileRenderPipelineDescriptor, objc_name="setMaxTotalThreadsPerThreadgroup") -TileRenderPipelineDescriptor_setMaxTotalThreadsPerThreadgroup :: proc(self: ^TileRenderPipelineDescriptor, maxTotalThreadsPerThreadgroup: NS.Integer) { +TileRenderPipelineDescriptor_setMaxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^TileRenderPipelineDescriptor, maxTotalThreadsPerThreadgroup: NS.Integer) { msgSend(nil, self, "setMaxTotalThreadsPerThreadgroup:", maxTotalThreadsPerThreadgroup) } @(objc_type=TileRenderPipelineDescriptor, objc_name="setRasterSampleCount") -TileRenderPipelineDescriptor_setRasterSampleCount :: proc(self: ^TileRenderPipelineDescriptor, rasterSampleCount: NS.Integer) { +TileRenderPipelineDescriptor_setRasterSampleCount :: #force_inline proc(self: ^TileRenderPipelineDescriptor, rasterSampleCount: NS.Integer) { msgSend(nil, self, "setRasterSampleCount:", rasterSampleCount) } @(objc_type=TileRenderPipelineDescriptor, objc_name="setThreadgroupSizeMatchesTileSize") -TileRenderPipelineDescriptor_setThreadgroupSizeMatchesTileSize :: proc(self: ^TileRenderPipelineDescriptor, threadgroupSizeMatchesTileSize: BOOL) { +TileRenderPipelineDescriptor_setThreadgroupSizeMatchesTileSize :: #force_inline proc(self: ^TileRenderPipelineDescriptor, threadgroupSizeMatchesTileSize: BOOL) { msgSend(nil, self, "setThreadgroupSizeMatchesTileSize:", threadgroupSizeMatchesTileSize) } @(objc_type=TileRenderPipelineDescriptor, objc_name="setTileFunction") -TileRenderPipelineDescriptor_setTileFunction :: proc(self: ^TileRenderPipelineDescriptor, tileFunction: ^NS.Object) { +TileRenderPipelineDescriptor_setTileFunction :: #force_inline proc(self: ^TileRenderPipelineDescriptor, tileFunction: ^NS.Object) { msgSend(nil, self, "setTileFunction:", tileFunction) } @(objc_type=TileRenderPipelineDescriptor, objc_name="threadgroupSizeMatchesTileSize") -TileRenderPipelineDescriptor_threadgroupSizeMatchesTileSize :: proc(self: ^TileRenderPipelineDescriptor) -> BOOL { +TileRenderPipelineDescriptor_threadgroupSizeMatchesTileSize :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "threadgroupSizeMatchesTileSize") } @(objc_type=TileRenderPipelineDescriptor, objc_name="tileBuffers") -TileRenderPipelineDescriptor_tileBuffers :: proc(self: ^TileRenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray { +TileRenderPipelineDescriptor_tileBuffers :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray { return msgSend(^PipelineBufferDescriptorArray, self, "tileBuffers") } @(objc_type=TileRenderPipelineDescriptor, objc_name="tileFunction") -TileRenderPipelineDescriptor_tileFunction :: proc(self: ^TileRenderPipelineDescriptor) -> ^TileRenderPipelineDescriptor { +TileRenderPipelineDescriptor_tileFunction :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> ^TileRenderPipelineDescriptor { return msgSend(^TileRenderPipelineDescriptor, self, "tileFunction") } @@ -4460,15 +4446,15 @@ Methods: Type :: struct { using _: NS.Object } @(objc_type=Type, objc_class_name="alloc") -Type_alloc :: proc() -> ^Type { +Type_alloc :: #force_inline proc() -> ^Type { return msgSend(^Type, Type, "alloc") } @(objc_type=Type, objc_name="init") -Type_init :: proc(self: ^Type) -> ^Type { +Type_init :: #force_inline proc(self: ^Type) -> ^Type { return msgSend(^Type, self, "init") } @(objc_type=Type, objc_name="dataType") -Type_dataType :: proc(self: ^Type) -> DataType { +Type_dataType :: #force_inline proc(self: ^Type) -> DataType { return msgSend(DataType, self, "dataType") } @@ -4492,35 +4478,35 @@ Methods: VertexAttribute :: struct { using _: NS.Object } @(objc_type=VertexAttribute, objc_class_name="alloc") -VertexAttribute_alloc :: proc() -> ^VertexAttribute { +VertexAttribute_alloc :: #force_inline proc() -> ^VertexAttribute { return msgSend(^VertexAttribute, VertexAttribute, "alloc") } @(objc_type=VertexAttribute, objc_name="init") -VertexAttribute_init :: proc(self: ^VertexAttribute) -> ^VertexAttribute { +VertexAttribute_init :: #force_inline proc(self: ^VertexAttribute) -> ^VertexAttribute { return msgSend(^VertexAttribute, self, "init") } @(objc_type=VertexAttribute, objc_name="attributeIndex") -VertexAttribute_attributeIndex :: proc(self: ^VertexAttribute) -> NS.Integer { +VertexAttribute_attributeIndex :: #force_inline proc(self: ^VertexAttribute) -> NS.Integer { return msgSend(NS.Integer, self, "attributeIndex") } @(objc_type=VertexAttribute, objc_name="attributeType") -VertexAttribute_attributeType :: proc(self: ^VertexAttribute) -> DataType { +VertexAttribute_attributeType :: #force_inline proc(self: ^VertexAttribute) -> DataType { return msgSend(DataType, self, "attributeType") } @(objc_type=VertexAttribute, objc_name="isActive") -VertexAttribute_isActive :: proc(self: ^VertexAttribute) -> BOOL { +VertexAttribute_isActive :: #force_inline proc(self: ^VertexAttribute) -> BOOL { return msgSend(BOOL, self, "isActive") } @(objc_type=VertexAttribute, objc_name="isPatchControlPointData") -VertexAttribute_isPatchControlPointData :: proc(self: ^VertexAttribute) -> BOOL { +VertexAttribute_isPatchControlPointData :: #force_inline proc(self: ^VertexAttribute) -> BOOL { return msgSend(BOOL, self, "isPatchControlPointData") } @(objc_type=VertexAttribute, objc_name="isPatchData") -VertexAttribute_isPatchData :: proc(self: ^VertexAttribute) -> BOOL { +VertexAttribute_isPatchData :: #force_inline proc(self: ^VertexAttribute) -> BOOL { return msgSend(BOOL, self, "isPatchData") } @(objc_type=VertexAttribute, objc_name="name") -VertexAttribute_name :: proc(self: ^VertexAttribute) -> ^NS.String { +VertexAttribute_name :: #force_inline proc(self: ^VertexAttribute) -> ^NS.String { return msgSend(^NS.String, self, "name") } @@ -4544,35 +4530,35 @@ Methods: VertexAttributeDescriptor :: struct { using _: NS.Copying(VertexAttributeDescriptor) } @(objc_type=VertexAttributeDescriptor, objc_class_name="alloc") -VertexAttributeDescriptor_alloc :: proc() -> ^VertexAttributeDescriptor { +VertexAttributeDescriptor_alloc :: #force_inline proc() -> ^VertexAttributeDescriptor { return msgSend(^VertexAttributeDescriptor, VertexAttributeDescriptor, "alloc") } @(objc_type=VertexAttributeDescriptor, objc_name="init") -VertexAttributeDescriptor_init :: proc(self: ^VertexAttributeDescriptor) -> ^VertexAttributeDescriptor { +VertexAttributeDescriptor_init :: #force_inline proc(self: ^VertexAttributeDescriptor) -> ^VertexAttributeDescriptor { return msgSend(^VertexAttributeDescriptor, self, "init") } @(objc_type=VertexAttributeDescriptor, objc_name="bufferIndex") -VertexAttributeDescriptor_bufferIndex :: proc(self: ^VertexAttributeDescriptor) -> NS.Integer { +VertexAttributeDescriptor_bufferIndex :: #force_inline proc(self: ^VertexAttributeDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "bufferIndex") } @(objc_type=VertexAttributeDescriptor, objc_name="format") -VertexAttributeDescriptor_format :: proc(self: ^VertexAttributeDescriptor) -> VertexFormat { +VertexAttributeDescriptor_format :: #force_inline proc(self: ^VertexAttributeDescriptor) -> VertexFormat { return msgSend(VertexFormat, self, "format") } @(objc_type=VertexAttributeDescriptor, objc_name="offset") -VertexAttributeDescriptor_offset :: proc(self: ^VertexAttributeDescriptor) -> NS.Integer { +VertexAttributeDescriptor_offset :: #force_inline proc(self: ^VertexAttributeDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "offset") } @(objc_type=VertexAttributeDescriptor, objc_name="setBufferIndex") -VertexAttributeDescriptor_setBufferIndex :: proc(self: ^VertexAttributeDescriptor, bufferIndex: NS.Integer) { +VertexAttributeDescriptor_setBufferIndex :: #force_inline proc(self: ^VertexAttributeDescriptor, bufferIndex: NS.Integer) { msgSend(nil, self, "setBufferIndex:", bufferIndex) } @(objc_type=VertexAttributeDescriptor, objc_name="setFormat") -VertexAttributeDescriptor_setFormat :: proc(self: ^VertexAttributeDescriptor, format: VertexFormat) { +VertexAttributeDescriptor_setFormat :: #force_inline proc(self: ^VertexAttributeDescriptor, format: VertexFormat) { msgSend(nil, self, "setFormat:", format) } @(objc_type=VertexAttributeDescriptor, objc_name="setOffset") -VertexAttributeDescriptor_setOffset :: proc(self: ^VertexAttributeDescriptor, offset: NS.Integer) { +VertexAttributeDescriptor_setOffset :: #force_inline proc(self: ^VertexAttributeDescriptor, offset: NS.Integer) { msgSend(nil, self, "setOffset:", offset) } @@ -4592,19 +4578,19 @@ Methods: VertexAttributeDescriptorArray :: struct { using _: NS.Object } @(objc_type=VertexAttributeDescriptorArray, objc_class_name="alloc") -VertexAttributeDescriptorArray_alloc :: proc() -> ^VertexAttributeDescriptorArray { +VertexAttributeDescriptorArray_alloc :: #force_inline proc() -> ^VertexAttributeDescriptorArray { return msgSend(^VertexAttributeDescriptorArray, VertexAttributeDescriptorArray, "alloc") } @(objc_type=VertexAttributeDescriptorArray, objc_name="init") -VertexAttributeDescriptorArray_init :: proc(self: ^VertexAttributeDescriptorArray) -> ^VertexAttributeDescriptorArray { +VertexAttributeDescriptorArray_init :: #force_inline proc(self: ^VertexAttributeDescriptorArray) -> ^VertexAttributeDescriptorArray { return msgSend(^VertexAttributeDescriptorArray, self, "init") } @(objc_type=VertexAttributeDescriptorArray, objc_name="objectAtIndexedSubscript") -VertexAttributeDescriptorArray_objectAtIndexedSubscript :: proc(self: ^VertexAttributeDescriptorArray, index: ^NS.Object) -> ^VertexAttributeDescriptor { +VertexAttributeDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^VertexAttributeDescriptorArray, index: ^NS.Object) -> ^VertexAttributeDescriptor { return msgSend(^VertexAttributeDescriptor, self, "objectAtIndexedSubscript:", index) } @(objc_type=VertexAttributeDescriptorArray, objc_name="setObject") -VertexAttributeDescriptorArray_setObject :: proc(self: ^VertexAttributeDescriptorArray, attributeDesc: ^VertexAttributeDescriptor, index: ^NS.Object) { +VertexAttributeDescriptorArray_setObject :: #force_inline proc(self: ^VertexAttributeDescriptorArray, attributeDesc: ^VertexAttributeDescriptor, index: ^NS.Object) { msgSend(nil, self, "setObject:atIndexedSubscript:", attributeDesc, index) } @@ -4628,35 +4614,35 @@ Methods: VertexBufferLayoutDescriptor :: struct { using _: NS.Copying(VertexBufferLayoutDescriptor) } @(objc_type=VertexBufferLayoutDescriptor, objc_class_name="alloc") -VertexBufferLayoutDescriptor_alloc :: proc() -> ^VertexBufferLayoutDescriptor { +VertexBufferLayoutDescriptor_alloc :: #force_inline proc() -> ^VertexBufferLayoutDescriptor { return msgSend(^VertexBufferLayoutDescriptor, VertexBufferLayoutDescriptor, "alloc") } @(objc_type=VertexBufferLayoutDescriptor, objc_name="init") -VertexBufferLayoutDescriptor_init :: proc(self: ^VertexBufferLayoutDescriptor) -> ^VertexBufferLayoutDescriptor { +VertexBufferLayoutDescriptor_init :: #force_inline proc(self: ^VertexBufferLayoutDescriptor) -> ^VertexBufferLayoutDescriptor { return msgSend(^VertexBufferLayoutDescriptor, self, "init") } @(objc_type=VertexBufferLayoutDescriptor, objc_name="setStepFunction") -VertexBufferLayoutDescriptor_setStepFunction :: proc(self: ^VertexBufferLayoutDescriptor, stepFunction: VertexStepFunction) { +VertexBufferLayoutDescriptor_setStepFunction :: #force_inline proc(self: ^VertexBufferLayoutDescriptor, stepFunction: VertexStepFunction) { msgSend(nil, self, "setStepFunction:", stepFunction) } @(objc_type=VertexBufferLayoutDescriptor, objc_name="setStepRate") -VertexBufferLayoutDescriptor_setStepRate :: proc(self: ^VertexBufferLayoutDescriptor, stepRate: NS.Integer) { +VertexBufferLayoutDescriptor_setStepRate :: #force_inline proc(self: ^VertexBufferLayoutDescriptor, stepRate: NS.Integer) { msgSend(nil, self, "setStepRate:", stepRate) } @(objc_type=VertexBufferLayoutDescriptor, objc_name="setStride") -VertexBufferLayoutDescriptor_setStride :: proc(self: ^VertexBufferLayoutDescriptor, stride: NS.Integer) { +VertexBufferLayoutDescriptor_setStride :: #force_inline proc(self: ^VertexBufferLayoutDescriptor, stride: NS.Integer) { msgSend(nil, self, "setStride:", stride) } @(objc_type=VertexBufferLayoutDescriptor, objc_name="stepFunction") -VertexBufferLayoutDescriptor_stepFunction :: proc(self: ^VertexBufferLayoutDescriptor) -> VertexStepFunction { +VertexBufferLayoutDescriptor_stepFunction :: #force_inline proc(self: ^VertexBufferLayoutDescriptor) -> VertexStepFunction { return msgSend(VertexStepFunction, self, "stepFunction") } @(objc_type=VertexBufferLayoutDescriptor, objc_name="stepRate") -VertexBufferLayoutDescriptor_stepRate :: proc(self: ^VertexBufferLayoutDescriptor) -> NS.Integer { +VertexBufferLayoutDescriptor_stepRate :: #force_inline proc(self: ^VertexBufferLayoutDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "stepRate") } @(objc_type=VertexBufferLayoutDescriptor, objc_name="stride") -VertexBufferLayoutDescriptor_stride :: proc(self: ^VertexBufferLayoutDescriptor) -> NS.Integer { +VertexBufferLayoutDescriptor_stride :: #force_inline proc(self: ^VertexBufferLayoutDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "stride") } @@ -4676,19 +4662,19 @@ Methods: VertexBufferLayoutDescriptorArray :: struct { using _: NS.Object } @(objc_type=VertexBufferLayoutDescriptorArray, objc_class_name="alloc") -VertexBufferLayoutDescriptorArray_alloc :: proc() -> ^VertexBufferLayoutDescriptorArray { +VertexBufferLayoutDescriptorArray_alloc :: #force_inline proc() -> ^VertexBufferLayoutDescriptorArray { return msgSend(^VertexBufferLayoutDescriptorArray, VertexBufferLayoutDescriptorArray, "alloc") } @(objc_type=VertexBufferLayoutDescriptorArray, objc_name="init") -VertexBufferLayoutDescriptorArray_init :: proc(self: ^VertexBufferLayoutDescriptorArray) -> ^VertexBufferLayoutDescriptorArray { +VertexBufferLayoutDescriptorArray_init :: #force_inline proc(self: ^VertexBufferLayoutDescriptorArray) -> ^VertexBufferLayoutDescriptorArray { return msgSend(^VertexBufferLayoutDescriptorArray, self, "init") } @(objc_type=VertexBufferLayoutDescriptorArray, objc_name="objectAtIndexedSubscript") -VertexBufferLayoutDescriptorArray_objectAtIndexedSubscript :: proc(self: ^VertexBufferLayoutDescriptorArray, index: ^NS.Object) -> ^VertexBufferLayoutDescriptor { +VertexBufferLayoutDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^VertexBufferLayoutDescriptorArray, index: ^NS.Object) -> ^VertexBufferLayoutDescriptor { return msgSend(^VertexBufferLayoutDescriptor, self, "objectAtIndexedSubscript:", index) } @(objc_type=VertexBufferLayoutDescriptorArray, objc_name="setObject") -VertexBufferLayoutDescriptorArray_setObject :: proc(self: ^VertexBufferLayoutDescriptorArray, bufferDesc: ^VertexBufferLayoutDescriptor, index: ^NS.Object) { +VertexBufferLayoutDescriptorArray_setObject :: #force_inline proc(self: ^VertexBufferLayoutDescriptorArray, bufferDesc: ^VertexBufferLayoutDescriptor, index: ^NS.Object) { msgSend(nil, self, "setObject:atIndexedSubscript:", bufferDesc, index) } @@ -4710,27 +4696,27 @@ Methods: VertexDescriptor :: struct { using _: NS.Copying(VertexDescriptor) } @(objc_type=VertexDescriptor, objc_class_name="alloc") -VertexDescriptor_alloc :: proc() -> ^VertexDescriptor { +VertexDescriptor_alloc :: #force_inline proc() -> ^VertexDescriptor { return msgSend(^VertexDescriptor, VertexDescriptor, "alloc") } @(objc_type=VertexDescriptor, objc_name="init") -VertexDescriptor_init :: proc(self: ^VertexDescriptor) -> ^VertexDescriptor { +VertexDescriptor_init :: #force_inline proc(self: ^VertexDescriptor) -> ^VertexDescriptor { return msgSend(^VertexDescriptor, self, "init") } @(objc_type=VertexDescriptor, objc_name="attributes") -VertexDescriptor_attributes :: proc(self: ^VertexDescriptor) -> ^VertexAttributeDescriptorArray { +VertexDescriptor_attributes :: #force_inline proc(self: ^VertexDescriptor) -> ^VertexAttributeDescriptorArray { return msgSend(^VertexAttributeDescriptorArray, self, "attributes") } @(objc_type=VertexDescriptor, objc_name="layouts") -VertexDescriptor_layouts :: proc(self: ^VertexDescriptor) -> ^VertexBufferLayoutDescriptorArray { +VertexDescriptor_layouts :: #force_inline proc(self: ^VertexDescriptor) -> ^VertexBufferLayoutDescriptorArray { return msgSend(^VertexBufferLayoutDescriptorArray, self, "layouts") } @(objc_type=VertexDescriptor, objc_name="reset") -VertexDescriptor_reset :: proc(self: ^VertexDescriptor) { +VertexDescriptor_reset :: #force_inline proc(self: ^VertexDescriptor) { msgSend(nil, self, "reset") } @(objc_type=VertexDescriptor, objc_class_name="vertexDescriptor") -VertexDescriptor_vertexDescriptor :: proc() -> ^VertexDescriptor { +VertexDescriptor_vertexDescriptor :: #force_inline proc() -> ^VertexDescriptor { return msgSend(^VertexDescriptor, VertexDescriptor, "vertexDescriptor") } @@ -4751,23 +4737,23 @@ Methods: VisibleFunctionTableDescriptor :: struct { using _: NS.Copying(VisibleFunctionTableDescriptor) } @(objc_type=VisibleFunctionTableDescriptor, objc_class_name="alloc") -VisibleFunctionTableDescriptor_alloc :: proc() -> ^VisibleFunctionTableDescriptor { +VisibleFunctionTableDescriptor_alloc :: #force_inline proc() -> ^VisibleFunctionTableDescriptor { return msgSend(^VisibleFunctionTableDescriptor, VisibleFunctionTableDescriptor, "alloc") } @(objc_type=VisibleFunctionTableDescriptor, objc_name="init") -VisibleFunctionTableDescriptor_init :: proc(self: ^VisibleFunctionTableDescriptor) -> ^VisibleFunctionTableDescriptor { +VisibleFunctionTableDescriptor_init :: #force_inline proc(self: ^VisibleFunctionTableDescriptor) -> ^VisibleFunctionTableDescriptor { return msgSend(^VisibleFunctionTableDescriptor, self, "init") } @(objc_type=VisibleFunctionTableDescriptor, objc_name="functionCount") -VisibleFunctionTableDescriptor_functionCount :: proc(self: ^VisibleFunctionTableDescriptor) -> NS.Integer { +VisibleFunctionTableDescriptor_functionCount :: #force_inline proc(self: ^VisibleFunctionTableDescriptor) -> NS.Integer { return msgSend(NS.Integer, self, "functionCount") } @(objc_type=VisibleFunctionTableDescriptor, objc_name="setFunctionCount") -VisibleFunctionTableDescriptor_setFunctionCount :: proc(self: ^VisibleFunctionTableDescriptor, functionCount: NS.Integer) { +VisibleFunctionTableDescriptor_setFunctionCount :: #force_inline proc(self: ^VisibleFunctionTableDescriptor, functionCount: NS.Integer) { msgSend(nil, self, "setFunctionCount:", functionCount) } @(objc_type=VisibleFunctionTableDescriptor, objc_class_name="visibleFunctionTableDescriptor") -VisibleFunctionTableDescriptor_visibleFunctionTableDescriptor :: proc() -> ^VisibleFunctionTableDescriptor { +VisibleFunctionTableDescriptor_visibleFunctionTableDescriptor :: #force_inline proc() -> ^VisibleFunctionTableDescriptor { return msgSend(^VisibleFunctionTableDescriptor, VisibleFunctionTableDescriptor, "visibleFunctionTableDescriptor") } @@ -4784,7 +4770,7 @@ Methods: AccelerationStructure :: struct { using _: NS.Object } @(objc_type=AccelerationStructure, objc_name="size") -AccelerationStructure_size :: proc(self: ^AccelerationStructure) -> NS.Integer { +AccelerationStructure_size :: #force_inline proc(self: ^AccelerationStructure) -> NS.Integer { return msgSend(NS.Integer, self, "size") } @@ -4812,51 +4798,51 @@ Methods: AccelerationStructureCommandEncoder :: struct { using _: NS.Object } @(objc_type=AccelerationStructureCommandEncoder, objc_name="buildAccelerationStructure") -AccelerationStructureCommandEncoder_buildAccelerationStructure :: proc(self: ^AccelerationStructureCommandEncoder, accelerationStructure: ^NS.Object, descriptor: ^AccelerationStructureDescriptor, scratchBuffer: ^NS.Object, scratchBufferOffset: ^NS.Object) { +AccelerationStructureCommandEncoder_buildAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, accelerationStructure: ^NS.Object, descriptor: ^AccelerationStructureDescriptor, scratchBuffer: ^NS.Object, scratchBufferOffset: ^NS.Object) { msgSend(nil, self, "buildAccelerationStructure:descriptor:scratchBuffer:scratchBufferOffset:", accelerationStructure, descriptor, scratchBuffer, scratchBufferOffset) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="copyAccelerationStructure") -AccelerationStructureCommandEncoder_copyAccelerationStructure :: proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^NS.Object, destinationAccelerationStructure: ^NS.Object) { +AccelerationStructureCommandEncoder_copyAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^NS.Object, destinationAccelerationStructure: ^NS.Object) { msgSend(nil, self, "copyAccelerationStructure:toAccelerationStructure:", sourceAccelerationStructure, destinationAccelerationStructure) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="copyAndCompactAccelerationStructure") -AccelerationStructureCommandEncoder_copyAndCompactAccelerationStructure :: proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^NS.Object, destinationAccelerationStructure: ^NS.Object) { +AccelerationStructureCommandEncoder_copyAndCompactAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^NS.Object, destinationAccelerationStructure: ^NS.Object) { msgSend(nil, self, "copyAndCompactAccelerationStructure:toAccelerationStructure:", sourceAccelerationStructure, destinationAccelerationStructure) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="refitAccelerationStructure") -AccelerationStructureCommandEncoder_refitAccelerationStructure :: proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^NS.Object, descriptor: ^AccelerationStructureDescriptor, destinationAccelerationStructure: ^NS.Object, scratchBuffer: ^NS.Object, scratchBufferOffset: ^NS.Object) { +AccelerationStructureCommandEncoder_refitAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^NS.Object, descriptor: ^AccelerationStructureDescriptor, destinationAccelerationStructure: ^NS.Object, scratchBuffer: ^NS.Object, scratchBufferOffset: ^NS.Object) { msgSend(nil, self, "refitAccelerationStructure:descriptor:destination:scratchBuffer:scratchBufferOffset:", sourceAccelerationStructure, descriptor, destinationAccelerationStructure, scratchBuffer, scratchBufferOffset) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="sampleCountersInBuffer") -AccelerationStructureCommandEncoder_sampleCountersInBuffer :: proc(self: ^AccelerationStructureCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) { +AccelerationStructureCommandEncoder_sampleCountersInBuffer :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) { msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="updateFence") -AccelerationStructureCommandEncoder_updateFence :: proc(self: ^AccelerationStructureCommandEncoder, fence: ^NS.Object) { +AccelerationStructureCommandEncoder_updateFence :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, fence: ^NS.Object) { msgSend(nil, self, "updateFence:", fence) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="useHeap") -AccelerationStructureCommandEncoder_useHeap :: proc(self: ^AccelerationStructureCommandEncoder, heap: ^NS.Object) { +AccelerationStructureCommandEncoder_useHeap :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, heap: ^NS.Object) { msgSend(nil, self, "useHeap:", heap) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="useHeaps") -AccelerationStructureCommandEncoder_useHeaps :: proc(self: ^AccelerationStructureCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object) { +AccelerationStructureCommandEncoder_useHeaps :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object) { msgSend(nil, self, "useHeaps:count:", heaps, count) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="useResource") -AccelerationStructureCommandEncoder_useResource :: proc(self: ^AccelerationStructureCommandEncoder, resource: ^NS.Object, usage: ResourceUsage) { +AccelerationStructureCommandEncoder_useResource :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, resource: ^NS.Object, usage: ResourceUsage) { msgSend(nil, self, "useResource:usage:", resource, usage) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="useResources") -AccelerationStructureCommandEncoder_useResources :: proc(self: ^AccelerationStructureCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage) { +AccelerationStructureCommandEncoder_useResources :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage) { msgSend(nil, self, "useResources:count:usage:", resources, count, usage) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="waitForFence") -AccelerationStructureCommandEncoder_waitForFence :: proc(self: ^AccelerationStructureCommandEncoder, fence: ^NS.Object) { +AccelerationStructureCommandEncoder_waitForFence :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, fence: ^NS.Object) { msgSend(nil, self, "waitForFence:", fence) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="writeCompactedAccelerationStructureSize") -AccelerationStructureCommandEncoder_writeCompactedAccelerationStructureSize :: proc(self: ^AccelerationStructureCommandEncoder, accelerationStructure: ^NS.Object, buffer: ^NS.Object, offset: ^NS.Object) { +AccelerationStructureCommandEncoder_writeCompactedAccelerationStructureSize :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, accelerationStructure: ^NS.Object, buffer: ^NS.Object, offset: ^NS.Object) { msgSend(nil, self, "writeCompactedAccelerationStructureSize:toBuffer:offset:", accelerationStructure, buffer, offset) } @@ -4898,107 +4884,107 @@ Methods: ArgumentEncoder :: struct { using _: NS.Object } @(objc_type=ArgumentEncoder, objc_name="alignment") -ArgumentEncoder_alignment :: proc(self: ^ArgumentEncoder) -> NS.Integer { +ArgumentEncoder_alignment :: #force_inline proc(self: ^ArgumentEncoder) -> NS.Integer { return msgSend(NS.Integer, self, "alignment") } @(objc_type=ArgumentEncoder, objc_name="constantDataAtIndex") -ArgumentEncoder_constantDataAtIndex :: proc(self: ^ArgumentEncoder, index: ^NS.Object) -> rawptr { +ArgumentEncoder_constantDataAtIndex :: #force_inline proc(self: ^ArgumentEncoder, index: ^NS.Object) -> rawptr { return msgSend(rawptr, self, "constantDataAtIndex:", index) } @(objc_type=ArgumentEncoder, objc_name="device") -ArgumentEncoder_device :: proc(self: ^ArgumentEncoder) -> ^ArgumentEncoder { +ArgumentEncoder_device :: #force_inline proc(self: ^ArgumentEncoder) -> ^ArgumentEncoder { return msgSend(^ArgumentEncoder, self, "device") } @(objc_type=ArgumentEncoder, objc_name="encodedLength") -ArgumentEncoder_encodedLength :: proc(self: ^ArgumentEncoder) -> NS.Integer { +ArgumentEncoder_encodedLength :: #force_inline proc(self: ^ArgumentEncoder) -> NS.Integer { return msgSend(NS.Integer, self, "encodedLength") } @(objc_type=ArgumentEncoder, objc_name="label") -ArgumentEncoder_label :: proc(self: ^ArgumentEncoder) -> ^NS.String { +ArgumentEncoder_label :: #force_inline proc(self: ^ArgumentEncoder) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=ArgumentEncoder, objc_name="newArgumentEncoderForBufferAtIndex") -ArgumentEncoder_newArgumentEncoderForBufferAtIndex :: proc(self: ^ArgumentEncoder, index: ^NS.Object) -> ^ArgumentEncoder { +ArgumentEncoder_newArgumentEncoderForBufferAtIndex :: #force_inline proc(self: ^ArgumentEncoder, index: ^NS.Object) -> ^ArgumentEncoder { return msgSend(^ArgumentEncoder, self, "newArgumentEncoderForBufferAtIndex:", index) } @(objc_type=ArgumentEncoder, objc_name="setAccelerationStructure") -ArgumentEncoder_setAccelerationStructure :: proc(self: ^ArgumentEncoder, accelerationStructure: ^NS.Object, index: ^NS.Object) { +ArgumentEncoder_setAccelerationStructure :: #force_inline proc(self: ^ArgumentEncoder, accelerationStructure: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setAccelerationStructure:atIndex:", accelerationStructure, index) } @(objc_type=ArgumentEncoder, objc_name="setArgumentBuffer_offset_") -ArgumentEncoder_setArgumentBuffer_offset_ :: proc(self: ^ArgumentEncoder, argumentBuffer: ^NS.Object, offset: ^NS.Object) { +ArgumentEncoder_setArgumentBuffer_offset_ :: #force_inline proc(self: ^ArgumentEncoder, argumentBuffer: ^NS.Object, offset: ^NS.Object) { msgSend(nil, self, "setArgumentBuffer:offset:", argumentBuffer, offset) } @(objc_type=ArgumentEncoder, objc_name="setArgumentBuffer_startOffset_arrayElement_") -ArgumentEncoder_setArgumentBuffer_startOffset_arrayElement_ :: proc(self: ^ArgumentEncoder, argumentBuffer: ^NS.Object, startOffset: ^NS.Object, arrayElement: ^NS.Object) { +ArgumentEncoder_setArgumentBuffer_startOffset_arrayElement_ :: #force_inline proc(self: ^ArgumentEncoder, argumentBuffer: ^NS.Object, startOffset: ^NS.Object, arrayElement: ^NS.Object) { msgSend(nil, self, "setArgumentBuffer:startOffset:arrayElement:", argumentBuffer, startOffset, arrayElement) } @(objc_type=ArgumentEncoder, objc_name="setBuffer") -ArgumentEncoder_setBuffer :: proc(self: ^ArgumentEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +ArgumentEncoder_setBuffer :: #force_inline proc(self: ^ArgumentEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=ArgumentEncoder, objc_name="setBuffers") -ArgumentEncoder_setBuffers :: proc(self: ^ArgumentEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { +ArgumentEncoder_setBuffers :: #force_inline proc(self: ^ArgumentEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { msgSend(nil, self, "setBuffers:offsets:withRange:", buffers, offsets, range) } @(objc_type=ArgumentEncoder, objc_name="setComputePipelineState") -ArgumentEncoder_setComputePipelineState :: proc(self: ^ArgumentEncoder, pipeline: ^NS.Object, index: ^NS.Object) { +ArgumentEncoder_setComputePipelineState :: #force_inline proc(self: ^ArgumentEncoder, pipeline: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setComputePipelineState:atIndex:", pipeline, index) } @(objc_type=ArgumentEncoder, objc_name="setComputePipelineStates") -ArgumentEncoder_setComputePipelineStates :: proc(self: ^ArgumentEncoder, pipelines: ^^NS.Object, range: NS.Range) { +ArgumentEncoder_setComputePipelineStates :: #force_inline proc(self: ^ArgumentEncoder, pipelines: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setComputePipelineStates:withRange:", pipelines, range) } @(objc_type=ArgumentEncoder, objc_name="setIndirectCommandBuffer") -ArgumentEncoder_setIndirectCommandBuffer :: proc(self: ^ArgumentEncoder, indirectCommandBuffer: ^NS.Object, index: ^NS.Object) { +ArgumentEncoder_setIndirectCommandBuffer :: #force_inline proc(self: ^ArgumentEncoder, indirectCommandBuffer: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setIndirectCommandBuffer:atIndex:", indirectCommandBuffer, index) } @(objc_type=ArgumentEncoder, objc_name="setIndirectCommandBuffers") -ArgumentEncoder_setIndirectCommandBuffers :: proc(self: ^ArgumentEncoder, buffers: ^^NS.Object, range: NS.Range) { +ArgumentEncoder_setIndirectCommandBuffers :: #force_inline proc(self: ^ArgumentEncoder, buffers: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setIndirectCommandBuffers:withRange:", buffers, range) } @(objc_type=ArgumentEncoder, objc_name="setIntersectionFunctionTable") -ArgumentEncoder_setIntersectionFunctionTable :: proc(self: ^ArgumentEncoder, intersectionFunctionTable: ^NS.Object, index: ^NS.Object) { +ArgumentEncoder_setIntersectionFunctionTable :: #force_inline proc(self: ^ArgumentEncoder, intersectionFunctionTable: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setIntersectionFunctionTable:atIndex:", intersectionFunctionTable, index) } @(objc_type=ArgumentEncoder, objc_name="setIntersectionFunctionTables") -ArgumentEncoder_setIntersectionFunctionTables :: proc(self: ^ArgumentEncoder, intersectionFunctionTables: ^^NS.Object, range: NS.Range) { +ArgumentEncoder_setIntersectionFunctionTables :: #force_inline proc(self: ^ArgumentEncoder, intersectionFunctionTables: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setIntersectionFunctionTables:withRange:", intersectionFunctionTables, range) } @(objc_type=ArgumentEncoder, objc_name="setLabel") -ArgumentEncoder_setLabel :: proc(self: ^ArgumentEncoder, label: ^NS.String) { +ArgumentEncoder_setLabel :: #force_inline proc(self: ^ArgumentEncoder, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=ArgumentEncoder, objc_name="setRenderPipelineState") -ArgumentEncoder_setRenderPipelineState :: proc(self: ^ArgumentEncoder, pipeline: ^NS.Object, index: ^NS.Object) { +ArgumentEncoder_setRenderPipelineState :: #force_inline proc(self: ^ArgumentEncoder, pipeline: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setRenderPipelineState:atIndex:", pipeline, index) } @(objc_type=ArgumentEncoder, objc_name="setRenderPipelineStates") -ArgumentEncoder_setRenderPipelineStates :: proc(self: ^ArgumentEncoder, pipelines: ^^NS.Object, range: NS.Range) { +ArgumentEncoder_setRenderPipelineStates :: #force_inline proc(self: ^ArgumentEncoder, pipelines: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setRenderPipelineStates:withRange:", pipelines, range) } @(objc_type=ArgumentEncoder, objc_name="setSamplerState") -ArgumentEncoder_setSamplerState :: proc(self: ^ArgumentEncoder, sampler: ^NS.Object, index: ^NS.Object) { +ArgumentEncoder_setSamplerState :: #force_inline proc(self: ^ArgumentEncoder, sampler: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setSamplerState:atIndex:", sampler, index) } @(objc_type=ArgumentEncoder, objc_name="setSamplerStates") -ArgumentEncoder_setSamplerStates :: proc(self: ^ArgumentEncoder, samplers: ^^NS.Object, range: NS.Range) { +ArgumentEncoder_setSamplerStates :: #force_inline proc(self: ^ArgumentEncoder, samplers: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setSamplerStates:withRange:", samplers, range) } @(objc_type=ArgumentEncoder, objc_name="setTexture") -ArgumentEncoder_setTexture :: proc(self: ^ArgumentEncoder, texture: ^NS.Object, index: ^NS.Object) { +ArgumentEncoder_setTexture :: #force_inline proc(self: ^ArgumentEncoder, texture: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setTexture:atIndex:", texture, index) } @(objc_type=ArgumentEncoder, objc_name="setTextures") -ArgumentEncoder_setTextures :: proc(self: ^ArgumentEncoder, textures: ^^NS.Object, range: NS.Range) { +ArgumentEncoder_setTextures :: #force_inline proc(self: ^ArgumentEncoder, textures: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setTextures:withRange:", textures, range) } @(objc_type=ArgumentEncoder, objc_name="setVisibleFunctionTable") -ArgumentEncoder_setVisibleFunctionTable :: proc(self: ^ArgumentEncoder, visibleFunctionTable: ^NS.Object, index: ^NS.Object) { +ArgumentEncoder_setVisibleFunctionTable :: #force_inline proc(self: ^ArgumentEncoder, visibleFunctionTable: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setVisibleFunctionTable:atIndex:", visibleFunctionTable, index) } @(objc_type=ArgumentEncoder, objc_name="setVisibleFunctionTables") -ArgumentEncoder_setVisibleFunctionTables :: proc(self: ^ArgumentEncoder, visibleFunctionTables: ^^NS.Object, range: NS.Range) { +ArgumentEncoder_setVisibleFunctionTables :: #force_inline proc(self: ^ArgumentEncoder, visibleFunctionTables: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setVisibleFunctionTables:withRange:", visibleFunctionTables, range) } @@ -5021,31 +5007,31 @@ Methods: BinaryArchive :: struct { using _: NS.Copying(BinaryArchive) } @(objc_type=BinaryArchive, objc_name="addComputePipelineFunctionsWithDescriptor") -BinaryArchive_addComputePipelineFunctionsWithDescriptor :: proc(self: ^BinaryArchive, descriptor: ^ComputePipelineDescriptor, error: ^^NS.Error ) -> BOOL { +BinaryArchive_addComputePipelineFunctionsWithDescriptor :: #force_inline proc(self: ^BinaryArchive, descriptor: ^ComputePipelineDescriptor, error: ^^NS.Error ) -> BOOL { return msgSend(BOOL, self, "addComputePipelineFunctionsWithDescriptor:error:", descriptor, error) } @(objc_type=BinaryArchive, objc_name="addRenderPipelineFunctionsWithDescriptor") -BinaryArchive_addRenderPipelineFunctionsWithDescriptor :: proc(self: ^BinaryArchive, descriptor: ^RenderPipelineDescriptor, error: ^^NS.Error ) -> BOOL { +BinaryArchive_addRenderPipelineFunctionsWithDescriptor :: #force_inline proc(self: ^BinaryArchive, descriptor: ^RenderPipelineDescriptor, error: ^^NS.Error ) -> BOOL { return msgSend(BOOL, self, "addRenderPipelineFunctionsWithDescriptor:error:", descriptor, error) } @(objc_type=BinaryArchive, objc_name="addTileRenderPipelineFunctionsWithDescriptor") -BinaryArchive_addTileRenderPipelineFunctionsWithDescriptor :: proc(self: ^BinaryArchive, descriptor: ^TileRenderPipelineDescriptor, error: ^^NS.Error ) -> BOOL { +BinaryArchive_addTileRenderPipelineFunctionsWithDescriptor :: #force_inline proc(self: ^BinaryArchive, descriptor: ^TileRenderPipelineDescriptor, error: ^^NS.Error ) -> BOOL { return msgSend(BOOL, self, "addTileRenderPipelineFunctionsWithDescriptor:error:", descriptor, error) } @(objc_type=BinaryArchive, objc_name="device") -BinaryArchive_device :: proc(self: ^BinaryArchive) -> ^BinaryArchive { +BinaryArchive_device :: #force_inline proc(self: ^BinaryArchive) -> ^BinaryArchive { return msgSend(^BinaryArchive, self, "device") } @(objc_type=BinaryArchive, objc_name="label") -BinaryArchive_label :: proc(self: ^BinaryArchive) -> ^NS.String { +BinaryArchive_label :: #force_inline proc(self: ^BinaryArchive) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=BinaryArchive, objc_name="serializeToURL") -BinaryArchive_serializeToURL :: proc(self: ^BinaryArchive, url: ^NS.URL, error: ^^NS.Error ) -> BOOL { +BinaryArchive_serializeToURL :: #force_inline proc(self: ^BinaryArchive, url: ^NS.URL, error: ^^NS.Error ) -> BOOL { return msgSend(BOOL, self, "serializeToURL:error:", url, error) } @(objc_type=BinaryArchive, objc_name="setLabel") -BinaryArchive_setLabel :: proc(self: ^BinaryArchive, label: ^NS.String) { +BinaryArchive_setLabel :: #force_inline proc(self: ^BinaryArchive, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @@ -5086,103 +5072,103 @@ Methods: BlitCommandEncoder :: struct { using _: NS.Object } @(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_") -BlitCommandEncoder_copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_ :: proc(self: ^BlitCommandEncoder, sourceBuffer: ^NS.Object, sourceOffset: ^NS.Object, sourceBytesPerRow: ^NS.Object, sourceBytesPerImage: ^NS.Object, sourceSize: Size, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, destinationOrigin: Origin) { +BlitCommandEncoder_copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^NS.Object, sourceOffset: ^NS.Object, sourceBytesPerRow: ^NS.Object, sourceBytesPerImage: ^NS.Object, sourceSize: Size, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, destinationOrigin: Origin) { msgSend(nil, self, "copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:", sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin) } @(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_") -BlitCommandEncoder_copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_ :: proc(self: ^BlitCommandEncoder, sourceBuffer: ^NS.Object, sourceOffset: ^NS.Object, sourceBytesPerRow: ^NS.Object, sourceBytesPerImage: ^NS.Object, sourceSize: Size, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, destinationOrigin: Origin, options: BlitOption) { +BlitCommandEncoder_copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^NS.Object, sourceOffset: ^NS.Object, sourceBytesPerRow: ^NS.Object, sourceBytesPerImage: ^NS.Object, sourceSize: Size, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, destinationOrigin: Origin, options: BlitOption) { msgSend(nil, self, "copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:options:", sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin, options) } @(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_") -BlitCommandEncoder_copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_ :: proc(self: ^BlitCommandEncoder, sourceBuffer: ^NS.Object, sourceOffset: ^NS.Object, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object, size: ^NS.Object) { +BlitCommandEncoder_copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^NS.Object, sourceOffset: ^NS.Object, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object, size: ^NS.Object) { msgSend(nil, self, "copyFromBuffer:sourceOffset:toBuffer:destinationOffset:size:", sourceBuffer, sourceOffset, destinationBuffer, destinationOffset, size) } @(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_") -BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_ :: proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object, destinationBytesPerRow: ^NS.Object, destinationBytesPerImage: ^NS.Object) { +BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object, destinationBytesPerRow: ^NS.Object, destinationBytesPerImage: ^NS.Object) { msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:", sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage) } @(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_") -BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_ :: proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object, destinationBytesPerRow: ^NS.Object, destinationBytesPerImage: ^NS.Object, options: BlitOption) { +BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object, destinationBytesPerRow: ^NS.Object, destinationBytesPerImage: ^NS.Object, options: BlitOption) { msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:options:", sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage, options) } @(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_") -BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_ :: proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, sourceOrigin: Origin, sourceSize: Size, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, destinationOrigin: Origin) { +BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, sourceOrigin: Origin, sourceSize: Size, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, destinationOrigin: Origin) { msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:", sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin) } @(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_") -BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_ :: proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, sliceCount: ^NS.Object, levelCount: ^NS.Object) { +BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, sliceCount: ^NS.Object, levelCount: ^NS.Object) { msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:toTexture:destinationSlice:destinationLevel:sliceCount:levelCount:", sourceTexture, sourceSlice, sourceLevel, destinationTexture, destinationSlice, destinationLevel, sliceCount, levelCount) } @(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_toTexture_") -BlitCommandEncoder_copyFromTexture_toTexture_ :: proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, destinationTexture: ^NS.Object) { +BlitCommandEncoder_copyFromTexture_toTexture_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, destinationTexture: ^NS.Object) { msgSend(nil, self, "copyFromTexture:toTexture:", sourceTexture, destinationTexture) } @(objc_type=BlitCommandEncoder, objc_name="copyIndirectCommandBuffer") -BlitCommandEncoder_copyIndirectCommandBuffer :: proc(self: ^BlitCommandEncoder, source: ^NS.Object, sourceRange: NS.Range, destination: ^NS.Object, destinationIndex: ^NS.Object) { +BlitCommandEncoder_copyIndirectCommandBuffer :: #force_inline proc(self: ^BlitCommandEncoder, source: ^NS.Object, sourceRange: NS.Range, destination: ^NS.Object, destinationIndex: ^NS.Object) { msgSend(nil, self, "copyIndirectCommandBuffer:sourceRange:destination:destinationIndex:", source, sourceRange, destination, destinationIndex) } @(objc_type=BlitCommandEncoder, objc_name="fillBuffer") -BlitCommandEncoder_fillBuffer :: proc(self: ^BlitCommandEncoder, buffer: ^NS.Object, range: NS.Range, value: u8) { +BlitCommandEncoder_fillBuffer :: #force_inline proc(self: ^BlitCommandEncoder, buffer: ^NS.Object, range: NS.Range, value: u8) { msgSend(nil, self, "fillBuffer:range:value:", buffer, range, value) } @(objc_type=BlitCommandEncoder, objc_name="generateMipmapsForTexture") -BlitCommandEncoder_generateMipmapsForTexture :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object) { +BlitCommandEncoder_generateMipmapsForTexture :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^NS.Object) { msgSend(nil, self, "generateMipmapsForTexture:", texture) } @(objc_type=BlitCommandEncoder, objc_name="getTextureAccessCounters") -BlitCommandEncoder_getTextureAccessCounters :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object, region: Region, mipLevel: ^NS.Object, slice: ^NS.Object, resetCounters: BOOL, countersBuffer: ^NS.Object, countersBufferOffset: ^NS.Object) { +BlitCommandEncoder_getTextureAccessCounters :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^NS.Object, region: Region, mipLevel: ^NS.Object, slice: ^NS.Object, resetCounters: BOOL, countersBuffer: ^NS.Object, countersBufferOffset: ^NS.Object) { msgSend(nil, self, "getTextureAccessCounters:region:mipLevel:slice:resetCounters:countersBuffer:countersBufferOffset:", texture, region, mipLevel, slice, resetCounters, countersBuffer, countersBufferOffset) } @(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForCPUAccess") -BlitCommandEncoder_optimizeContentsForCPUAccess :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object) { +BlitCommandEncoder_optimizeContentsForCPUAccess :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^NS.Object) { msgSend(nil, self, "optimizeContentsForCPUAccess:", texture) } @(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForCPUAccess_slice_level_") -BlitCommandEncoder_optimizeContentsForCPUAccess_slice_level_ :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object, slice: ^NS.Object, level: ^NS.Object) { +BlitCommandEncoder_optimizeContentsForCPUAccess_slice_level_ :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^NS.Object, slice: ^NS.Object, level: ^NS.Object) { msgSend(nil, self, "optimizeContentsForCPUAccess:slice:level:", texture, slice, level) } @(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForGPUAccess") -BlitCommandEncoder_optimizeContentsForGPUAccess :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object) { +BlitCommandEncoder_optimizeContentsForGPUAccess :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^NS.Object) { msgSend(nil, self, "optimizeContentsForGPUAccess:", texture) } @(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForGPUAccess_slice_level_") -BlitCommandEncoder_optimizeContentsForGPUAccess_slice_level_ :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object, slice: ^NS.Object, level: ^NS.Object) { +BlitCommandEncoder_optimizeContentsForGPUAccess_slice_level_ :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^NS.Object, slice: ^NS.Object, level: ^NS.Object) { msgSend(nil, self, "optimizeContentsForGPUAccess:slice:level:", texture, slice, level) } @(objc_type=BlitCommandEncoder, objc_name="optimizeIndirectCommandBuffer") -BlitCommandEncoder_optimizeIndirectCommandBuffer :: proc(self: ^BlitCommandEncoder, indirectCommandBuffer: ^NS.Object, range: NS.Range) { +BlitCommandEncoder_optimizeIndirectCommandBuffer :: #force_inline proc(self: ^BlitCommandEncoder, indirectCommandBuffer: ^NS.Object, range: NS.Range) { msgSend(nil, self, "optimizeIndirectCommandBuffer:withRange:", indirectCommandBuffer, range) } @(objc_type=BlitCommandEncoder, objc_name="resetCommandsInBuffer") -BlitCommandEncoder_resetCommandsInBuffer :: proc(self: ^BlitCommandEncoder, buffer: ^NS.Object, range: NS.Range) { +BlitCommandEncoder_resetCommandsInBuffer :: #force_inline proc(self: ^BlitCommandEncoder, buffer: ^NS.Object, range: NS.Range) { msgSend(nil, self, "resetCommandsInBuffer:withRange:", buffer, range) } @(objc_type=BlitCommandEncoder, objc_name="resetTextureAccessCounters") -BlitCommandEncoder_resetTextureAccessCounters :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object, region: Region, mipLevel: ^NS.Object, slice: ^NS.Object) { +BlitCommandEncoder_resetTextureAccessCounters :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^NS.Object, region: Region, mipLevel: ^NS.Object, slice: ^NS.Object) { msgSend(nil, self, "resetTextureAccessCounters:region:mipLevel:slice:", texture, region, mipLevel, slice) } @(objc_type=BlitCommandEncoder, objc_name="resolveCounters") -BlitCommandEncoder_resolveCounters :: proc(self: ^BlitCommandEncoder, sampleBuffer: ^NS.Object, range: NS.Range, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object) { +BlitCommandEncoder_resolveCounters :: #force_inline proc(self: ^BlitCommandEncoder, sampleBuffer: ^NS.Object, range: NS.Range, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object) { msgSend(nil, self, "resolveCounters:inRange:destinationBuffer:destinationOffset:", sampleBuffer, range, destinationBuffer, destinationOffset) } @(objc_type=BlitCommandEncoder, objc_name="sampleCountersInBuffer") -BlitCommandEncoder_sampleCountersInBuffer :: proc(self: ^BlitCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) { +BlitCommandEncoder_sampleCountersInBuffer :: #force_inline proc(self: ^BlitCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) { msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier) } @(objc_type=BlitCommandEncoder, objc_name="synchronizeResource") -BlitCommandEncoder_synchronizeResource :: proc(self: ^BlitCommandEncoder, resource: ^NS.Object) { +BlitCommandEncoder_synchronizeResource :: #force_inline proc(self: ^BlitCommandEncoder, resource: ^NS.Object) { msgSend(nil, self, "synchronizeResource:", resource) } @(objc_type=BlitCommandEncoder, objc_name="synchronizeTexture") -BlitCommandEncoder_synchronizeTexture :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object, slice: ^NS.Object, level: ^NS.Object) { +BlitCommandEncoder_synchronizeTexture :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^NS.Object, slice: ^NS.Object, level: ^NS.Object) { msgSend(nil, self, "synchronizeTexture:slice:level:", texture, slice, level) } @(objc_type=BlitCommandEncoder, objc_name="updateFence") -BlitCommandEncoder_updateFence :: proc(self: ^BlitCommandEncoder, fence: ^NS.Object) { +BlitCommandEncoder_updateFence :: #force_inline proc(self: ^BlitCommandEncoder, fence: ^NS.Object) { msgSend(nil, self, "updateFence:", fence) } @(objc_type=BlitCommandEncoder, objc_name="waitForFence") -BlitCommandEncoder_waitForFence :: proc(self: ^BlitCommandEncoder, fence: ^NS.Object) { +BlitCommandEncoder_waitForFence :: #force_inline proc(self: ^BlitCommandEncoder, fence: ^NS.Object) { msgSend(nil, self, "waitForFence:", fence) } @@ -5206,35 +5192,35 @@ Methods: Buffer :: struct { using _: NS.Object } @(objc_type=Buffer, objc_name="addDebugMarker") -Buffer_addDebugMarker :: proc(self: ^Buffer, marker: ^NS.String, range: NS.Range) { +Buffer_addDebugMarker :: #force_inline proc(self: ^Buffer, marker: ^NS.String, range: NS.Range) { msgSend(nil, self, "addDebugMarker:range:", marker, range) } @(objc_type=Buffer, objc_name="contents") -Buffer_contents :: proc(self: ^Buffer) -> rawptr { +Buffer_contents :: #force_inline proc(self: ^Buffer) -> rawptr { return msgSend(rawptr, self, "contents") } @(objc_type=Buffer, objc_name="didModifyRange") -Buffer_didModifyRange :: proc(self: ^Buffer, range: NS.Range) { +Buffer_didModifyRange :: #force_inline proc(self: ^Buffer, range: NS.Range) { msgSend(nil, self, "didModifyRange:", range) } @(objc_type=Buffer, objc_name="length") -Buffer_length :: proc(self: ^Buffer) -> NS.Integer { +Buffer_length :: #force_inline proc(self: ^Buffer) -> NS.Integer { return msgSend(NS.Integer, self, "length") } @(objc_type=Buffer, objc_name="newRemoteBufferViewForDevice") -Buffer_newRemoteBufferViewForDevice :: proc(self: ^Buffer, device: ^NS.Object) -> ^Buffer { +Buffer_newRemoteBufferViewForDevice :: #force_inline proc(self: ^Buffer, device: ^NS.Object) -> ^Buffer { return msgSend(^Buffer, self, "newRemoteBufferViewForDevice:", device) } @(objc_type=Buffer, objc_name="newTextureWithDescriptor") -Buffer_newTextureWithDescriptor :: proc(self: ^Buffer, descriptor: ^TextureDescriptor, offset: ^NS.Object, bytesPerRow: ^NS.Object) -> ^Buffer { +Buffer_newTextureWithDescriptor :: #force_inline proc(self: ^Buffer, descriptor: ^TextureDescriptor, offset: ^NS.Object, bytesPerRow: ^NS.Object) -> ^Buffer { return msgSend(^Buffer, self, "newTextureWithDescriptor:offset:bytesPerRow:", descriptor, offset, bytesPerRow) } @(objc_type=Buffer, objc_name="remoteStorageBuffer") -Buffer_remoteStorageBuffer :: proc(self: ^Buffer) -> ^Buffer { +Buffer_remoteStorageBuffer :: #force_inline proc(self: ^Buffer) -> ^Buffer { return msgSend(^Buffer, self, "remoteStorageBuffer") } @(objc_type=Buffer, objc_name="removeAllDebugMarkers") -Buffer_removeAllDebugMarkers :: proc(self: ^Buffer) { +Buffer_removeAllDebugMarkers :: #force_inline proc(self: ^Buffer) { msgSend(nil, self, "removeAllDebugMarkers") } @@ -5256,27 +5242,27 @@ Methods: CaptureScope :: struct { using _: NS.Object } @(objc_type=CaptureScope, objc_name="beginScope") -CaptureScope_beginScope :: proc(self: ^CaptureScope) { +CaptureScope_beginScope :: #force_inline proc(self: ^CaptureScope) { msgSend(nil, self, "beginScope") } @(objc_type=CaptureScope, objc_name="commandQueue") -CaptureScope_commandQueue :: proc(self: ^CaptureScope) -> ^CaptureScope { +CaptureScope_commandQueue :: #force_inline proc(self: ^CaptureScope) -> ^CaptureScope { return msgSend(^CaptureScope, self, "commandQueue") } @(objc_type=CaptureScope, objc_name="device") -CaptureScope_device :: proc(self: ^CaptureScope) -> ^CaptureScope { +CaptureScope_device :: #force_inline proc(self: ^CaptureScope) -> ^CaptureScope { return msgSend(^CaptureScope, self, "device") } @(objc_type=CaptureScope, objc_name="endScope") -CaptureScope_endScope :: proc(self: ^CaptureScope) { +CaptureScope_endScope :: #force_inline proc(self: ^CaptureScope) { msgSend(nil, self, "endScope") } @(objc_type=CaptureScope, objc_name="label") -CaptureScope_label :: proc(self: ^CaptureScope) -> ^NS.String { +CaptureScope_label :: #force_inline proc(self: ^CaptureScope) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=CaptureScope, objc_name="setLabel") -CaptureScope_setLabel :: proc(self: ^CaptureScope, label: ^NS.String) { +CaptureScope_setLabel :: #force_inline proc(self: ^CaptureScope, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @@ -5328,147 +5314,147 @@ Methods: CommandBuffer :: struct { using _: NS.Object } @(objc_type=CommandBuffer, objc_name="GPUEndTime") -CommandBuffer_GPUEndTime :: proc(self: ^CommandBuffer) -> CFTimeInterval { +CommandBuffer_GPUEndTime :: #force_inline proc(self: ^CommandBuffer) -> CFTimeInterval { return msgSend(CFTimeInterval, self, "GPUEndTime") } @(objc_type=CommandBuffer, objc_name="GPUStartTime") -CommandBuffer_GPUStartTime :: proc(self: ^CommandBuffer) -> CFTimeInterval { +CommandBuffer_GPUStartTime :: #force_inline proc(self: ^CommandBuffer) -> CFTimeInterval { return msgSend(CFTimeInterval, self, "GPUStartTime") } @(objc_type=CommandBuffer, objc_name="accelerationStructureCommandEncoder") -CommandBuffer_accelerationStructureCommandEncoder :: proc(self: ^CommandBuffer) -> ^CommandBuffer { +CommandBuffer_accelerationStructureCommandEncoder :: #force_inline proc(self: ^CommandBuffer) -> ^CommandBuffer { return msgSend(^CommandBuffer, self, "accelerationStructureCommandEncoder") } @(objc_type=CommandBuffer, objc_name="addCompletedHandler") -CommandBuffer_addCompletedHandler :: proc(self: ^CommandBuffer, block: CommandBufferHandler) { +CommandBuffer_addCompletedHandler :: #force_inline proc(self: ^CommandBuffer, block: CommandBufferHandler) { msgSend(nil, self, "addCompletedHandler:", block) } @(objc_type=CommandBuffer, objc_name="addScheduledHandler") -CommandBuffer_addScheduledHandler :: proc(self: ^CommandBuffer, block: CommandBufferHandler) { +CommandBuffer_addScheduledHandler :: #force_inline proc(self: ^CommandBuffer, block: CommandBufferHandler) { msgSend(nil, self, "addScheduledHandler:", block) } @(objc_type=CommandBuffer, objc_name="blitCommandEncoder") -CommandBuffer_blitCommandEncoder :: proc(self: ^CommandBuffer) -> ^CommandBuffer { +CommandBuffer_blitCommandEncoder :: #force_inline proc(self: ^CommandBuffer) -> ^CommandBuffer { return msgSend(^CommandBuffer, self, "blitCommandEncoder") } @(objc_type=CommandBuffer, objc_name="blitCommandEncoderWithDescriptor") -CommandBuffer_blitCommandEncoderWithDescriptor :: proc(self: ^CommandBuffer, blitPassDescriptor: ^BlitPassDescriptor) -> ^CommandBuffer { +CommandBuffer_blitCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, blitPassDescriptor: ^BlitPassDescriptor) -> ^CommandBuffer { return msgSend(^CommandBuffer, self, "blitCommandEncoderWithDescriptor:", blitPassDescriptor) } @(objc_type=CommandBuffer, objc_name="commandQueue") -CommandBuffer_commandQueue :: proc(self: ^CommandBuffer) -> ^CommandBuffer { +CommandBuffer_commandQueue :: #force_inline proc(self: ^CommandBuffer) -> ^CommandBuffer { return msgSend(^CommandBuffer, self, "commandQueue") } @(objc_type=CommandBuffer, objc_name="commit") -CommandBuffer_commit :: proc(self: ^CommandBuffer) { +CommandBuffer_commit :: #force_inline proc(self: ^CommandBuffer) { msgSend(nil, self, "commit") } @(objc_type=CommandBuffer, objc_name="computeCommandEncoder") -CommandBuffer_computeCommandEncoder :: proc(self: ^CommandBuffer) -> ^CommandBuffer { +CommandBuffer_computeCommandEncoder :: #force_inline proc(self: ^CommandBuffer) -> ^CommandBuffer { return msgSend(^CommandBuffer, self, "computeCommandEncoder") } @(objc_type=CommandBuffer, objc_name="computeCommandEncoderWithDescriptor") -CommandBuffer_computeCommandEncoderWithDescriptor :: proc(self: ^CommandBuffer, computePassDescriptor: ^ComputePassDescriptor) -> ^CommandBuffer { +CommandBuffer_computeCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, computePassDescriptor: ^ComputePassDescriptor) -> ^CommandBuffer { return msgSend(^CommandBuffer, self, "computeCommandEncoderWithDescriptor:", computePassDescriptor) } @(objc_type=CommandBuffer, objc_name="computeCommandEncoderWithDispatchType") -CommandBuffer_computeCommandEncoderWithDispatchType :: proc(self: ^CommandBuffer, dispatchType: DispatchType) -> ^CommandBuffer { +CommandBuffer_computeCommandEncoderWithDispatchType :: #force_inline proc(self: ^CommandBuffer, dispatchType: DispatchType) -> ^CommandBuffer { return msgSend(^CommandBuffer, self, "computeCommandEncoderWithDispatchType:", dispatchType) } @(objc_type=CommandBuffer, objc_name="device") -CommandBuffer_device :: proc(self: ^CommandBuffer) -> ^CommandBuffer { +CommandBuffer_device :: #force_inline proc(self: ^CommandBuffer) -> ^CommandBuffer { return msgSend(^CommandBuffer, self, "device") } @(objc_type=CommandBuffer, objc_name="encodeSignalEvent") -CommandBuffer_encodeSignalEvent :: proc(self: ^CommandBuffer, event: ^NS.Object, value: u64) { +CommandBuffer_encodeSignalEvent :: #force_inline proc(self: ^CommandBuffer, event: ^NS.Object, value: u64) { msgSend(nil, self, "encodeSignalEvent:value:", event, value) } @(objc_type=CommandBuffer, objc_name="encodeWaitForEvent") -CommandBuffer_encodeWaitForEvent :: proc(self: ^CommandBuffer, event: ^NS.Object, value: u64) { +CommandBuffer_encodeWaitForEvent :: #force_inline proc(self: ^CommandBuffer, event: ^NS.Object, value: u64) { msgSend(nil, self, "encodeWaitForEvent:value:", event, value) } @(objc_type=CommandBuffer, objc_name="enqueue") -CommandBuffer_enqueue :: proc(self: ^CommandBuffer) { +CommandBuffer_enqueue :: #force_inline proc(self: ^CommandBuffer) { msgSend(nil, self, "enqueue") } @(objc_type=CommandBuffer, objc_name="error") -CommandBuffer_error :: proc(self: ^CommandBuffer) -> ^NS.Error { +CommandBuffer_error :: #force_inline proc(self: ^CommandBuffer) -> ^NS.Error { return msgSend(^NS.Error, self, "error") } @(objc_type=CommandBuffer, objc_name="errorOptions") -CommandBuffer_errorOptions :: proc(self: ^CommandBuffer) -> CommandBufferErrorOption { +CommandBuffer_errorOptions :: #force_inline proc(self: ^CommandBuffer) -> CommandBufferErrorOption { return msgSend(CommandBufferErrorOption, self, "errorOptions") } @(objc_type=CommandBuffer, objc_name="kernelEndTime") -CommandBuffer_kernelEndTime :: proc(self: ^CommandBuffer) -> CFTimeInterval { +CommandBuffer_kernelEndTime :: #force_inline proc(self: ^CommandBuffer) -> CFTimeInterval { return msgSend(CFTimeInterval, self, "kernelEndTime") } @(objc_type=CommandBuffer, objc_name="kernelStartTime") -CommandBuffer_kernelStartTime :: proc(self: ^CommandBuffer) -> CFTimeInterval { +CommandBuffer_kernelStartTime :: #force_inline proc(self: ^CommandBuffer) -> CFTimeInterval { return msgSend(CFTimeInterval, self, "kernelStartTime") } @(objc_type=CommandBuffer, objc_name="label") -CommandBuffer_label :: proc(self: ^CommandBuffer) -> ^NS.String { +CommandBuffer_label :: #force_inline proc(self: ^CommandBuffer) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=CommandBuffer, objc_name="logs") -CommandBuffer_logs :: proc(self: ^CommandBuffer) -> ^CommandBuffer { +CommandBuffer_logs :: #force_inline proc(self: ^CommandBuffer) -> ^CommandBuffer { return msgSend(^CommandBuffer, self, "logs") } @(objc_type=CommandBuffer, objc_name="parallelRenderCommandEncoderWithDescriptor") -CommandBuffer_parallelRenderCommandEncoderWithDescriptor :: proc(self: ^CommandBuffer, renderPassDescriptor: ^RenderPassDescriptor) -> ^CommandBuffer { +CommandBuffer_parallelRenderCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, renderPassDescriptor: ^RenderPassDescriptor) -> ^CommandBuffer { return msgSend(^CommandBuffer, self, "parallelRenderCommandEncoderWithDescriptor:", renderPassDescriptor) } @(objc_type=CommandBuffer, objc_name="popDebugGroup") -CommandBuffer_popDebugGroup :: proc(self: ^CommandBuffer) { +CommandBuffer_popDebugGroup :: #force_inline proc(self: ^CommandBuffer) { msgSend(nil, self, "popDebugGroup") } @(objc_type=CommandBuffer, objc_name="presentDrawable") -CommandBuffer_presentDrawable :: proc(self: ^CommandBuffer, drawable: ^NS.Object) { +CommandBuffer_presentDrawable :: #force_inline proc(self: ^CommandBuffer, drawable: ^NS.Object) { msgSend(nil, self, "presentDrawable:", drawable) } @(objc_type=CommandBuffer, objc_name="presentDrawable_afterMinimumDuration_") -CommandBuffer_presentDrawable_afterMinimumDuration_ :: proc(self: ^CommandBuffer, drawable: ^NS.Object, duration: CFTimeInterval) { +CommandBuffer_presentDrawable_afterMinimumDuration_ :: #force_inline proc(self: ^CommandBuffer, drawable: ^NS.Object, duration: CFTimeInterval) { msgSend(nil, self, "presentDrawable:afterMinimumDuration:", drawable, duration) } @(objc_type=CommandBuffer, objc_name="presentDrawable_atTime_") -CommandBuffer_presentDrawable_atTime_ :: proc(self: ^CommandBuffer, drawable: ^NS.Object, presentationTime: CFTimeInterval) { +CommandBuffer_presentDrawable_atTime_ :: #force_inline proc(self: ^CommandBuffer, drawable: ^NS.Object, presentationTime: CFTimeInterval) { msgSend(nil, self, "presentDrawable:atTime:", drawable, presentationTime) } @(objc_type=CommandBuffer, objc_name="pushDebugGroup") -CommandBuffer_pushDebugGroup :: proc(self: ^CommandBuffer, string: ^NS.String) { +CommandBuffer_pushDebugGroup :: #force_inline proc(self: ^CommandBuffer, string: ^NS.String) { msgSend(nil, self, "pushDebugGroup:", string) } @(objc_type=CommandBuffer, objc_name="renderCommandEncoderWithDescriptor") -CommandBuffer_renderCommandEncoderWithDescriptor :: proc(self: ^CommandBuffer, renderPassDescriptor: ^RenderPassDescriptor) -> ^CommandBuffer { +CommandBuffer_renderCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, renderPassDescriptor: ^RenderPassDescriptor) -> ^CommandBuffer { return msgSend(^CommandBuffer, self, "renderCommandEncoderWithDescriptor:", renderPassDescriptor) } @(objc_type=CommandBuffer, objc_name="resourceStateCommandEncoder") -CommandBuffer_resourceStateCommandEncoder :: proc(self: ^CommandBuffer) -> ^CommandBuffer { +CommandBuffer_resourceStateCommandEncoder :: #force_inline proc(self: ^CommandBuffer) -> ^CommandBuffer { return msgSend(^CommandBuffer, self, "resourceStateCommandEncoder") } @(objc_type=CommandBuffer, objc_name="resourceStateCommandEncoderWithDescriptor") -CommandBuffer_resourceStateCommandEncoderWithDescriptor :: proc(self: ^CommandBuffer, resourceStatePassDescriptor: ^ResourceStatePassDescriptor) -> ^CommandBuffer { +CommandBuffer_resourceStateCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, resourceStatePassDescriptor: ^ResourceStatePassDescriptor) -> ^CommandBuffer { return msgSend(^CommandBuffer, self, "resourceStateCommandEncoderWithDescriptor:", resourceStatePassDescriptor) } @(objc_type=CommandBuffer, objc_name="retainedReferences") -CommandBuffer_retainedReferences :: proc(self: ^CommandBuffer) -> BOOL { +CommandBuffer_retainedReferences :: #force_inline proc(self: ^CommandBuffer) -> BOOL { return msgSend(BOOL, self, "retainedReferences") } @(objc_type=CommandBuffer, objc_name="setLabel") -CommandBuffer_setLabel :: proc(self: ^CommandBuffer, label: ^NS.String) { +CommandBuffer_setLabel :: #force_inline proc(self: ^CommandBuffer, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=CommandBuffer, objc_name="status") -CommandBuffer_status :: proc(self: ^CommandBuffer) -> CommandBufferStatus { +CommandBuffer_status :: #force_inline proc(self: ^CommandBuffer) -> CommandBufferStatus { return msgSend(CommandBufferStatus, self, "status") } @(objc_type=CommandBuffer, objc_name="waitUntilCompleted") -CommandBuffer_waitUntilCompleted :: proc(self: ^CommandBuffer) { +CommandBuffer_waitUntilCompleted :: #force_inline proc(self: ^CommandBuffer) { msgSend(nil, self, "waitUntilCompleted") } @(objc_type=CommandBuffer, objc_name="waitUntilScheduled") -CommandBuffer_waitUntilScheduled :: proc(self: ^CommandBuffer) { +CommandBuffer_waitUntilScheduled :: #force_inline proc(self: ^CommandBuffer) { msgSend(nil, self, "waitUntilScheduled") } @@ -5487,15 +5473,15 @@ Methods: CommandBufferEncoderInfo :: struct { using _: NS.Object } @(objc_type=CommandBufferEncoderInfo, objc_name="debugSignposts") -CommandBufferEncoderInfo_debugSignposts :: proc(self: ^CommandBufferEncoderInfo) -> ^NS.Array { +CommandBufferEncoderInfo_debugSignposts :: #force_inline proc(self: ^CommandBufferEncoderInfo) -> ^NS.Array { return msgSend(^NS.Array, self, "debugSignposts") } @(objc_type=CommandBufferEncoderInfo, objc_name="errorState") -CommandBufferEncoderInfo_errorState :: proc(self: ^CommandBufferEncoderInfo) -> CommandEncoderErrorState { +CommandBufferEncoderInfo_errorState :: #force_inline proc(self: ^CommandBufferEncoderInfo) -> CommandEncoderErrorState { return msgSend(CommandEncoderErrorState, self, "errorState") } @(objc_type=CommandBufferEncoderInfo, objc_name="label") -CommandBufferEncoderInfo_label :: proc(self: ^CommandBufferEncoderInfo) -> ^NS.String { +CommandBufferEncoderInfo_label :: #force_inline proc(self: ^CommandBufferEncoderInfo) -> ^NS.String { return msgSend(^NS.String, self, "label") } @@ -5518,31 +5504,31 @@ Methods: CommandEncoder :: struct { using _: NS.Object } @(objc_type=CommandEncoder, objc_name="device") -CommandEncoder_device :: proc(self: ^CommandEncoder) -> ^CommandEncoder { +CommandEncoder_device :: #force_inline proc(self: ^CommandEncoder) -> ^CommandEncoder { return msgSend(^CommandEncoder, self, "device") } @(objc_type=CommandEncoder, objc_name="endEncoding") -CommandEncoder_endEncoding :: proc(self: ^CommandEncoder) { +CommandEncoder_endEncoding :: #force_inline proc(self: ^CommandEncoder) { msgSend(nil, self, "endEncoding") } @(objc_type=CommandEncoder, objc_name="insertDebugSignpost") -CommandEncoder_insertDebugSignpost :: proc(self: ^CommandEncoder, string: ^NS.String) { +CommandEncoder_insertDebugSignpost :: #force_inline proc(self: ^CommandEncoder, string: ^NS.String) { msgSend(nil, self, "insertDebugSignpost:", string) } @(objc_type=CommandEncoder, objc_name="label") -CommandEncoder_label :: proc(self: ^CommandEncoder) -> ^NS.String { +CommandEncoder_label :: #force_inline proc(self: ^CommandEncoder) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=CommandEncoder, objc_name="popDebugGroup") -CommandEncoder_popDebugGroup :: proc(self: ^CommandEncoder) { +CommandEncoder_popDebugGroup :: #force_inline proc(self: ^CommandEncoder) { msgSend(nil, self, "popDebugGroup") } @(objc_type=CommandEncoder, objc_name="pushDebugGroup") -CommandEncoder_pushDebugGroup :: proc(self: ^CommandEncoder, string: ^NS.String) { +CommandEncoder_pushDebugGroup :: #force_inline proc(self: ^CommandEncoder, string: ^NS.String) { msgSend(nil, self, "pushDebugGroup:", string) } @(objc_type=CommandEncoder, objc_name="setLabel") -CommandEncoder_setLabel :: proc(self: ^CommandEncoder, label: ^NS.String) { +CommandEncoder_setLabel :: #force_inline proc(self: ^CommandEncoder, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @@ -5565,31 +5551,31 @@ Methods: CommandQueue :: struct { using _: NS.Object } @(objc_type=CommandQueue, objc_name="commandBuffer") -CommandQueue_commandBuffer :: proc(self: ^CommandQueue) -> ^CommandQueue { +CommandQueue_commandBuffer :: #force_inline proc(self: ^CommandQueue) -> ^CommandQueue { return msgSend(^CommandQueue, self, "commandBuffer") } @(objc_type=CommandQueue, objc_name="commandBufferWithDescriptor") -CommandQueue_commandBufferWithDescriptor :: proc(self: ^CommandQueue, descriptor: ^CommandBufferDescriptor) -> ^CommandQueue { +CommandQueue_commandBufferWithDescriptor :: #force_inline proc(self: ^CommandQueue, descriptor: ^CommandBufferDescriptor) -> ^CommandQueue { return msgSend(^CommandQueue, self, "commandBufferWithDescriptor:", descriptor) } @(objc_type=CommandQueue, objc_name="commandBufferWithUnretainedReferences") -CommandQueue_commandBufferWithUnretainedReferences :: proc(self: ^CommandQueue) -> ^CommandQueue { +CommandQueue_commandBufferWithUnretainedReferences :: #force_inline proc(self: ^CommandQueue) -> ^CommandQueue { return msgSend(^CommandQueue, self, "commandBufferWithUnretainedReferences") } @(objc_type=CommandQueue, objc_name="device") -CommandQueue_device :: proc(self: ^CommandQueue) -> ^CommandQueue { +CommandQueue_device :: #force_inline proc(self: ^CommandQueue) -> ^CommandQueue { return msgSend(^CommandQueue, self, "device") } @(objc_type=CommandQueue, objc_name="insertDebugCaptureBoundary") -CommandQueue_insertDebugCaptureBoundary :: proc(self: ^CommandQueue) { +CommandQueue_insertDebugCaptureBoundary :: #force_inline proc(self: ^CommandQueue) { msgSend(nil, self, "insertDebugCaptureBoundary") } @(objc_type=CommandQueue, objc_name="label") -CommandQueue_label :: proc(self: ^CommandQueue) -> ^NS.String { +CommandQueue_label :: #force_inline proc(self: ^CommandQueue) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=CommandQueue, objc_name="setLabel") -CommandQueue_setLabel :: proc(self: ^CommandQueue, label: ^NS.String) { +CommandQueue_setLabel :: #force_inline proc(self: ^CommandQueue, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @@ -5640,143 +5626,143 @@ Methods: ComputeCommandEncoder :: struct { using _: NS.Object } @(objc_type=ComputeCommandEncoder, objc_name="dispatchThreadgroups") -ComputeCommandEncoder_dispatchThreadgroups :: proc(self: ^ComputeCommandEncoder, threadgroupsPerGrid: Size, threadsPerThreadgroup: Size) { +ComputeCommandEncoder_dispatchThreadgroups :: #force_inline proc(self: ^ComputeCommandEncoder, threadgroupsPerGrid: Size, threadsPerThreadgroup: Size) { msgSend(nil, self, "dispatchThreadgroups:threadsPerThreadgroup:", threadgroupsPerGrid, threadsPerThreadgroup) } @(objc_type=ComputeCommandEncoder, objc_name="dispatchThreadgroupsWithIndirectBuffer") -ComputeCommandEncoder_dispatchThreadgroupsWithIndirectBuffer :: proc(self: ^ComputeCommandEncoder, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object, threadsPerThreadgroup: Size) { +ComputeCommandEncoder_dispatchThreadgroupsWithIndirectBuffer :: #force_inline proc(self: ^ComputeCommandEncoder, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object, threadsPerThreadgroup: Size) { msgSend(nil, self, "dispatchThreadgroupsWithIndirectBuffer:indirectBufferOffset:threadsPerThreadgroup:", indirectBuffer, indirectBufferOffset, threadsPerThreadgroup) } @(objc_type=ComputeCommandEncoder, objc_name="dispatchThreads") -ComputeCommandEncoder_dispatchThreads :: proc(self: ^ComputeCommandEncoder, threadsPerGrid: Size, threadsPerThreadgroup: Size) { +ComputeCommandEncoder_dispatchThreads :: #force_inline proc(self: ^ComputeCommandEncoder, threadsPerGrid: Size, threadsPerThreadgroup: Size) { msgSend(nil, self, "dispatchThreads:threadsPerThreadgroup:", threadsPerGrid, threadsPerThreadgroup) } @(objc_type=ComputeCommandEncoder, objc_name="dispatchType") -ComputeCommandEncoder_dispatchType :: proc(self: ^ComputeCommandEncoder) -> DispatchType { +ComputeCommandEncoder_dispatchType :: #force_inline proc(self: ^ComputeCommandEncoder) -> DispatchType { return msgSend(DispatchType, self, "dispatchType") } @(objc_type=ComputeCommandEncoder, objc_name="executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_") -ComputeCommandEncoder_executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_ :: proc(self: ^ComputeCommandEncoder, indirectCommandbuffer: ^NS.Object, indirectRangeBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { +ComputeCommandEncoder_executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^ComputeCommandEncoder, indirectCommandbuffer: ^NS.Object, indirectRangeBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { msgSend(nil, self, "executeCommandsInBuffer:indirectBuffer:indirectBufferOffset:", indirectCommandbuffer, indirectRangeBuffer, indirectBufferOffset) } @(objc_type=ComputeCommandEncoder, objc_name="executeCommandsInBuffer_withRange_") -ComputeCommandEncoder_executeCommandsInBuffer_withRange_ :: proc(self: ^ComputeCommandEncoder, indirectCommandBuffer: ^NS.Object, executionRange: NS.Range) { +ComputeCommandEncoder_executeCommandsInBuffer_withRange_ :: #force_inline proc(self: ^ComputeCommandEncoder, indirectCommandBuffer: ^NS.Object, executionRange: NS.Range) { msgSend(nil, self, "executeCommandsInBuffer:withRange:", indirectCommandBuffer, executionRange) } @(objc_type=ComputeCommandEncoder, objc_name="memoryBarrierWithResources") -ComputeCommandEncoder_memoryBarrierWithResources :: proc(self: ^ComputeCommandEncoder, resources: ^^NS.Object, count: ^NS.Object) { +ComputeCommandEncoder_memoryBarrierWithResources :: #force_inline proc(self: ^ComputeCommandEncoder, resources: ^^NS.Object, count: ^NS.Object) { msgSend(nil, self, "memoryBarrierWithResources:count:", resources, count) } @(objc_type=ComputeCommandEncoder, objc_name="memoryBarrierWithScope") -ComputeCommandEncoder_memoryBarrierWithScope :: proc(self: ^ComputeCommandEncoder, scope: BarrierScope) { +ComputeCommandEncoder_memoryBarrierWithScope :: #force_inline proc(self: ^ComputeCommandEncoder, scope: BarrierScope) { msgSend(nil, self, "memoryBarrierWithScope:", scope) } @(objc_type=ComputeCommandEncoder, objc_name="sampleCountersInBuffer") -ComputeCommandEncoder_sampleCountersInBuffer :: proc(self: ^ComputeCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) { +ComputeCommandEncoder_sampleCountersInBuffer :: #force_inline proc(self: ^ComputeCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) { msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier) } @(objc_type=ComputeCommandEncoder, objc_name="setAccelerationStructure") -ComputeCommandEncoder_setAccelerationStructure :: proc(self: ^ComputeCommandEncoder, accelerationStructure: ^NS.Object, bufferIndex: ^NS.Object) { +ComputeCommandEncoder_setAccelerationStructure :: #force_inline proc(self: ^ComputeCommandEncoder, accelerationStructure: ^NS.Object, bufferIndex: ^NS.Object) { msgSend(nil, self, "setAccelerationStructure:atBufferIndex:", accelerationStructure, bufferIndex) } @(objc_type=ComputeCommandEncoder, objc_name="setBuffer") -ComputeCommandEncoder_setBuffer :: proc(self: ^ComputeCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +ComputeCommandEncoder_setBuffer :: #force_inline proc(self: ^ComputeCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=ComputeCommandEncoder, objc_name="setBufferOffset") -ComputeCommandEncoder_setBufferOffset :: proc(self: ^ComputeCommandEncoder, offset: ^NS.Object, index: ^NS.Object) { +ComputeCommandEncoder_setBufferOffset :: #force_inline proc(self: ^ComputeCommandEncoder, offset: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setBufferOffset:atIndex:", offset, index) } @(objc_type=ComputeCommandEncoder, objc_name="setBuffers") -ComputeCommandEncoder_setBuffers :: proc(self: ^ComputeCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { +ComputeCommandEncoder_setBuffers :: #force_inline proc(self: ^ComputeCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { msgSend(nil, self, "setBuffers:offsets:withRange:", buffers, offsets, range) } @(objc_type=ComputeCommandEncoder, objc_name="setBytes") -ComputeCommandEncoder_setBytes :: proc(self: ^ComputeCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) { +ComputeCommandEncoder_setBytes :: #force_inline proc(self: ^ComputeCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setBytes:length:atIndex:", bytes, length, index) } @(objc_type=ComputeCommandEncoder, objc_name="setComputePipelineState") -ComputeCommandEncoder_setComputePipelineState :: proc(self: ^ComputeCommandEncoder, pipelineState: ^NS.Object) { +ComputeCommandEncoder_setComputePipelineState :: #force_inline proc(self: ^ComputeCommandEncoder, pipelineState: ^NS.Object) { msgSend(nil, self, "setComputePipelineState:", pipelineState) } @(objc_type=ComputeCommandEncoder, objc_name="setImageblockWidth") -ComputeCommandEncoder_setImageblockWidth :: proc(self: ^ComputeCommandEncoder, width: ^NS.Object, height: ^NS.Object) { +ComputeCommandEncoder_setImageblockWidth :: #force_inline proc(self: ^ComputeCommandEncoder, width: ^NS.Object, height: ^NS.Object) { msgSend(nil, self, "setImageblockWidth:height:", width, height) } @(objc_type=ComputeCommandEncoder, objc_name="setIntersectionFunctionTable") -ComputeCommandEncoder_setIntersectionFunctionTable :: proc(self: ^ComputeCommandEncoder, intersectionFunctionTable: ^NS.Object, bufferIndex: ^NS.Object) { +ComputeCommandEncoder_setIntersectionFunctionTable :: #force_inline proc(self: ^ComputeCommandEncoder, intersectionFunctionTable: ^NS.Object, bufferIndex: ^NS.Object) { msgSend(nil, self, "setIntersectionFunctionTable:atBufferIndex:", intersectionFunctionTable, bufferIndex) } @(objc_type=ComputeCommandEncoder, objc_name="setIntersectionFunctionTables") -ComputeCommandEncoder_setIntersectionFunctionTables :: proc(self: ^ComputeCommandEncoder, intersectionFunctionTables: ^^NS.Object, range: NS.Range) { +ComputeCommandEncoder_setIntersectionFunctionTables :: #force_inline proc(self: ^ComputeCommandEncoder, intersectionFunctionTables: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setIntersectionFunctionTables:withBufferRange:", intersectionFunctionTables, range) } @(objc_type=ComputeCommandEncoder, objc_name="setSamplerState_atIndex_") -ComputeCommandEncoder_setSamplerState_atIndex_ :: proc(self: ^ComputeCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) { +ComputeCommandEncoder_setSamplerState_atIndex_ :: #force_inline proc(self: ^ComputeCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setSamplerState:atIndex:", sampler, index) } @(objc_type=ComputeCommandEncoder, objc_name="setSamplerState_lodMinClamp_lodMaxClamp_atIndex_") -ComputeCommandEncoder_setSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: proc(self: ^ComputeCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) { +ComputeCommandEncoder_setSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: #force_inline proc(self: ^ComputeCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) { msgSend(nil, self, "setSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } @(objc_type=ComputeCommandEncoder, objc_name="setSamplerStates_lodMinClamps_lodMaxClamps_withRange_") -ComputeCommandEncoder_setSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: proc(self: ^ComputeCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { +ComputeCommandEncoder_setSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: #force_inline proc(self: ^ComputeCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { msgSend(nil, self, "setSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range) } @(objc_type=ComputeCommandEncoder, objc_name="setSamplerStates_withRange_") -ComputeCommandEncoder_setSamplerStates_withRange_ :: proc(self: ^ComputeCommandEncoder, samplers: ^^NS.Object, range: NS.Range) { +ComputeCommandEncoder_setSamplerStates_withRange_ :: #force_inline proc(self: ^ComputeCommandEncoder, samplers: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setSamplerStates:withRange:", samplers, range) } @(objc_type=ComputeCommandEncoder, objc_name="setStageInRegion") -ComputeCommandEncoder_setStageInRegion :: proc(self: ^ComputeCommandEncoder, region: Region) { +ComputeCommandEncoder_setStageInRegion :: #force_inline proc(self: ^ComputeCommandEncoder, region: Region) { msgSend(nil, self, "setStageInRegion:", region) } @(objc_type=ComputeCommandEncoder, objc_name="setStageInRegionWithIndirectBuffer") -ComputeCommandEncoder_setStageInRegionWithIndirectBuffer :: proc(self: ^ComputeCommandEncoder, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { +ComputeCommandEncoder_setStageInRegionWithIndirectBuffer :: #force_inline proc(self: ^ComputeCommandEncoder, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { msgSend(nil, self, "setStageInRegionWithIndirectBuffer:indirectBufferOffset:", indirectBuffer, indirectBufferOffset) } @(objc_type=ComputeCommandEncoder, objc_name="setTexture") -ComputeCommandEncoder_setTexture :: proc(self: ^ComputeCommandEncoder, texture: ^NS.Object, index: ^NS.Object) { +ComputeCommandEncoder_setTexture :: #force_inline proc(self: ^ComputeCommandEncoder, texture: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setTexture:atIndex:", texture, index) } @(objc_type=ComputeCommandEncoder, objc_name="setTextures") -ComputeCommandEncoder_setTextures :: proc(self: ^ComputeCommandEncoder, textures: ^^NS.Object, range: NS.Range) { +ComputeCommandEncoder_setTextures :: #force_inline proc(self: ^ComputeCommandEncoder, textures: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setTextures:withRange:", textures, range) } @(objc_type=ComputeCommandEncoder, objc_name="setThreadgroupMemoryLength") -ComputeCommandEncoder_setThreadgroupMemoryLength :: proc(self: ^ComputeCommandEncoder, length: ^NS.Object, index: ^NS.Object) { +ComputeCommandEncoder_setThreadgroupMemoryLength :: #force_inline proc(self: ^ComputeCommandEncoder, length: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setThreadgroupMemoryLength:atIndex:", length, index) } @(objc_type=ComputeCommandEncoder, objc_name="setVisibleFunctionTable") -ComputeCommandEncoder_setVisibleFunctionTable :: proc(self: ^ComputeCommandEncoder, visibleFunctionTable: ^NS.Object, bufferIndex: ^NS.Object) { +ComputeCommandEncoder_setVisibleFunctionTable :: #force_inline proc(self: ^ComputeCommandEncoder, visibleFunctionTable: ^NS.Object, bufferIndex: ^NS.Object) { msgSend(nil, self, "setVisibleFunctionTable:atBufferIndex:", visibleFunctionTable, bufferIndex) } @(objc_type=ComputeCommandEncoder, objc_name="setVisibleFunctionTables") -ComputeCommandEncoder_setVisibleFunctionTables :: proc(self: ^ComputeCommandEncoder, visibleFunctionTables: ^^NS.Object, range: NS.Range) { +ComputeCommandEncoder_setVisibleFunctionTables :: #force_inline proc(self: ^ComputeCommandEncoder, visibleFunctionTables: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setVisibleFunctionTables:withBufferRange:", visibleFunctionTables, range) } @(objc_type=ComputeCommandEncoder, objc_name="updateFence") -ComputeCommandEncoder_updateFence :: proc(self: ^ComputeCommandEncoder, fence: ^NS.Object) { +ComputeCommandEncoder_updateFence :: #force_inline proc(self: ^ComputeCommandEncoder, fence: ^NS.Object) { msgSend(nil, self, "updateFence:", fence) } @(objc_type=ComputeCommandEncoder, objc_name="useHeap") -ComputeCommandEncoder_useHeap :: proc(self: ^ComputeCommandEncoder, heap: ^NS.Object) { +ComputeCommandEncoder_useHeap :: #force_inline proc(self: ^ComputeCommandEncoder, heap: ^NS.Object) { msgSend(nil, self, "useHeap:", heap) } @(objc_type=ComputeCommandEncoder, objc_name="useHeaps") -ComputeCommandEncoder_useHeaps :: proc(self: ^ComputeCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object) { +ComputeCommandEncoder_useHeaps :: #force_inline proc(self: ^ComputeCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object) { msgSend(nil, self, "useHeaps:count:", heaps, count) } @(objc_type=ComputeCommandEncoder, objc_name="useResource") -ComputeCommandEncoder_useResource :: proc(self: ^ComputeCommandEncoder, resource: ^NS.Object, usage: ResourceUsage) { +ComputeCommandEncoder_useResource :: #force_inline proc(self: ^ComputeCommandEncoder, resource: ^NS.Object, usage: ResourceUsage) { msgSend(nil, self, "useResource:usage:", resource, usage) } @(objc_type=ComputeCommandEncoder, objc_name="useResources") -ComputeCommandEncoder_useResources :: proc(self: ^ComputeCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage) { +ComputeCommandEncoder_useResources :: #force_inline proc(self: ^ComputeCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage) { msgSend(nil, self, "useResources:count:usage:", resources, count, usage) } @(objc_type=ComputeCommandEncoder, objc_name="waitForFence") -ComputeCommandEncoder_waitForFence :: proc(self: ^ComputeCommandEncoder, fence: ^NS.Object) { +ComputeCommandEncoder_waitForFence :: #force_inline proc(self: ^ComputeCommandEncoder, fence: ^NS.Object) { msgSend(nil, self, "waitForFence:", fence) } @@ -5803,47 +5789,47 @@ Methods: ComputePipelineState :: struct { using _: NS.Object } @(objc_type=ComputePipelineState, objc_name="device") -ComputePipelineState_device :: proc(self: ^ComputePipelineState) -> ^ComputePipelineState { +ComputePipelineState_device :: #force_inline proc(self: ^ComputePipelineState) -> ^ComputePipelineState { return msgSend(^ComputePipelineState, self, "device") } @(objc_type=ComputePipelineState, objc_name="functionHandleWithFunction") -ComputePipelineState_functionHandleWithFunction :: proc(self: ^ComputePipelineState, function: ^NS.Object) -> ^ComputePipelineState { +ComputePipelineState_functionHandleWithFunction :: #force_inline proc(self: ^ComputePipelineState, function: ^NS.Object) -> ^ComputePipelineState { return msgSend(^ComputePipelineState, self, "functionHandleWithFunction:", function) } @(objc_type=ComputePipelineState, objc_name="imageblockMemoryLengthForDimensions") -ComputePipelineState_imageblockMemoryLengthForDimensions :: proc(self: ^ComputePipelineState, imageblockDimensions: Size) -> ^ComputePipelineState { +ComputePipelineState_imageblockMemoryLengthForDimensions :: #force_inline proc(self: ^ComputePipelineState, imageblockDimensions: Size) -> ^ComputePipelineState { return msgSend(^ComputePipelineState, self, "imageblockMemoryLengthForDimensions:", imageblockDimensions) } @(objc_type=ComputePipelineState, objc_name="label") -ComputePipelineState_label :: proc(self: ^ComputePipelineState) -> ^NS.String { +ComputePipelineState_label :: #force_inline proc(self: ^ComputePipelineState) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=ComputePipelineState, objc_name="maxTotalThreadsPerThreadgroup") -ComputePipelineState_maxTotalThreadsPerThreadgroup :: proc(self: ^ComputePipelineState) -> NS.Integer { +ComputePipelineState_maxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^ComputePipelineState) -> NS.Integer { return msgSend(NS.Integer, self, "maxTotalThreadsPerThreadgroup") } @(objc_type=ComputePipelineState, objc_name="newComputePipelineStateWithAdditionalBinaryFunctions") -ComputePipelineState_newComputePipelineStateWithAdditionalBinaryFunctions :: proc(self: ^ComputePipelineState, functions: ^NS.Array, error: ^^NS.Error ) -> ^ComputePipelineState { +ComputePipelineState_newComputePipelineStateWithAdditionalBinaryFunctions :: #force_inline proc(self: ^ComputePipelineState, functions: ^NS.Array, error: ^^NS.Error ) -> ^ComputePipelineState { return msgSend(^ComputePipelineState, self, "newComputePipelineStateWithAdditionalBinaryFunctions:error:", functions, error) } @(objc_type=ComputePipelineState, objc_name="newIntersectionFunctionTableWithDescriptor") -ComputePipelineState_newIntersectionFunctionTableWithDescriptor :: proc(self: ^ComputePipelineState, descriptor: ^IntersectionFunctionTableDescriptor) -> ^ComputePipelineState { +ComputePipelineState_newIntersectionFunctionTableWithDescriptor :: #force_inline proc(self: ^ComputePipelineState, descriptor: ^IntersectionFunctionTableDescriptor) -> ^ComputePipelineState { return msgSend(^ComputePipelineState, self, "newIntersectionFunctionTableWithDescriptor:", descriptor) } @(objc_type=ComputePipelineState, objc_name="newVisibleFunctionTableWithDescriptor") -ComputePipelineState_newVisibleFunctionTableWithDescriptor :: proc(self: ^ComputePipelineState, descriptor: ^VisibleFunctionTableDescriptor) -> ^ComputePipelineState { +ComputePipelineState_newVisibleFunctionTableWithDescriptor :: #force_inline proc(self: ^ComputePipelineState, descriptor: ^VisibleFunctionTableDescriptor) -> ^ComputePipelineState { return msgSend(^ComputePipelineState, self, "newVisibleFunctionTableWithDescriptor:", descriptor) } @(objc_type=ComputePipelineState, objc_name="staticThreadgroupMemoryLength") -ComputePipelineState_staticThreadgroupMemoryLength :: proc(self: ^ComputePipelineState) -> NS.Integer { +ComputePipelineState_staticThreadgroupMemoryLength :: #force_inline proc(self: ^ComputePipelineState) -> NS.Integer { return msgSend(NS.Integer, self, "staticThreadgroupMemoryLength") } @(objc_type=ComputePipelineState, objc_name="supportIndirectCommandBuffers") -ComputePipelineState_supportIndirectCommandBuffers :: proc(self: ^ComputePipelineState) -> BOOL { +ComputePipelineState_supportIndirectCommandBuffers :: #force_inline proc(self: ^ComputePipelineState) -> BOOL { return msgSend(BOOL, self, "supportIndirectCommandBuffers") } @(objc_type=ComputePipelineState, objc_name="threadExecutionWidth") -ComputePipelineState_threadExecutionWidth :: proc(self: ^ComputePipelineState) -> NS.Integer { +ComputePipelineState_threadExecutionWidth :: #force_inline proc(self: ^ComputePipelineState) -> NS.Integer { return msgSend(NS.Integer, self, "threadExecutionWidth") } @@ -5860,7 +5846,7 @@ Methods: Counter :: struct { using _: NS.Object } @(objc_type=Counter, objc_name="name") -Counter_name :: proc(self: ^Counter) -> ^NS.String { +Counter_name :: #force_inline proc(self: ^Counter) -> ^NS.String { return msgSend(^NS.String, self, "name") } @@ -5880,19 +5866,19 @@ Methods: CounterSampleBuffer :: struct { using _: NS.Object } @(objc_type=CounterSampleBuffer, objc_name="device") -CounterSampleBuffer_device :: proc(self: ^CounterSampleBuffer) -> ^CounterSampleBuffer { +CounterSampleBuffer_device :: #force_inline proc(self: ^CounterSampleBuffer) -> ^CounterSampleBuffer { return msgSend(^CounterSampleBuffer, self, "device") } @(objc_type=CounterSampleBuffer, objc_name="label") -CounterSampleBuffer_label :: proc(self: ^CounterSampleBuffer) -> ^NS.String { +CounterSampleBuffer_label :: #force_inline proc(self: ^CounterSampleBuffer) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=CounterSampleBuffer, objc_name="resolveCounterRange") -CounterSampleBuffer_resolveCounterRange :: proc(self: ^CounterSampleBuffer, range: NS.Range) -> ^NS.Data { +CounterSampleBuffer_resolveCounterRange :: #force_inline proc(self: ^CounterSampleBuffer, range: NS.Range) -> ^NS.Data { return msgSend(^NS.Data, self, "resolveCounterRange:", range) } @(objc_type=CounterSampleBuffer, objc_name="sampleCount") -CounterSampleBuffer_sampleCount :: proc(self: ^CounterSampleBuffer) -> NS.Integer { +CounterSampleBuffer_sampleCount :: #force_inline proc(self: ^CounterSampleBuffer) -> NS.Integer { return msgSend(NS.Integer, self, "sampleCount") } @@ -5910,11 +5896,11 @@ Methods: CounterSet :: struct { using _: NS.Object } @(objc_type=CounterSet, objc_name="counters") -CounterSet_counters :: proc(self: ^CounterSet) -> ^NS.Array { +CounterSet_counters :: #force_inline proc(self: ^CounterSet) -> ^NS.Array { return msgSend(^NS.Array, self, "counters") } @(objc_type=CounterSet, objc_name="name") -CounterSet_name :: proc(self: ^CounterSet) -> ^NS.String { +CounterSet_name :: #force_inline proc(self: ^CounterSet) -> ^NS.String { return msgSend(^NS.String, self, "name") } @@ -5932,11 +5918,11 @@ Methods: DepthStencilState :: struct { using _: NS.Object } @(objc_type=DepthStencilState, objc_name="device") -DepthStencilState_device :: proc(self: ^DepthStencilState) -> ^DepthStencilState { +DepthStencilState_device :: #force_inline proc(self: ^DepthStencilState) -> ^DepthStencilState { return msgSend(^DepthStencilState, self, "device") } @(objc_type=DepthStencilState, objc_name="label") -DepthStencilState_label :: proc(self: ^DepthStencilState) -> ^NS.String { +DepthStencilState_label :: #force_inline proc(self: ^DepthStencilState) -> ^NS.String { return msgSend(^NS.String, self, "label") } @@ -6047,383 +6033,383 @@ Methods: Device :: struct { using _: NS.Object } @(objc_type=Device, objc_name="accelerationStructureSizesWithDescriptor") -Device_accelerationStructureSizesWithDescriptor :: proc(self: ^Device, descriptor: ^AccelerationStructureDescriptor) -> AccelerationStructureSizes { +Device_accelerationStructureSizesWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^AccelerationStructureDescriptor) -> AccelerationStructureSizes { return msgSend(AccelerationStructureSizes, self, "accelerationStructureSizesWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="areBarycentricCoordsSupported") -Device_areBarycentricCoordsSupported :: proc(self: ^Device) -> BOOL { +Device_areBarycentricCoordsSupported :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "areBarycentricCoordsSupported") } @(objc_type=Device, objc_name="areProgrammableSamplePositionsSupported") -Device_areProgrammableSamplePositionsSupported :: proc(self: ^Device) -> BOOL { +Device_areProgrammableSamplePositionsSupported :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "areProgrammableSamplePositionsSupported") } @(objc_type=Device, objc_name="areRasterOrderGroupsSupported") -Device_areRasterOrderGroupsSupported :: proc(self: ^Device) -> BOOL { +Device_areRasterOrderGroupsSupported :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "areRasterOrderGroupsSupported") } @(objc_type=Device, objc_name="argumentBuffersSupport") -Device_argumentBuffersSupport :: proc(self: ^Device) -> ArgumentBuffersTier { +Device_argumentBuffersSupport :: #force_inline proc(self: ^Device) -> ArgumentBuffersTier { return msgSend(ArgumentBuffersTier, self, "argumentBuffersSupport") } @(objc_type=Device, objc_name="convertSparsePixelRegions") -Device_convertSparsePixelRegions :: proc(self: ^Device, pixelRegions: ^Region, tileRegions: ^Region, tileSize: Size, mode: SparseTextureRegionAlignmentMode, numRegions: ^NS.Object) { +Device_convertSparsePixelRegions :: #force_inline proc(self: ^Device, pixelRegions: ^Region, tileRegions: ^Region, tileSize: Size, mode: SparseTextureRegionAlignmentMode, numRegions: ^NS.Object) { msgSend(nil, self, "convertSparsePixelRegions:toTileRegions:withTileSize:alignmentMode:numRegions:", pixelRegions, tileRegions, tileSize, mode, numRegions) } @(objc_type=Device, objc_name="convertSparseTileRegions") -Device_convertSparseTileRegions :: proc(self: ^Device, tileRegions: ^Region, pixelRegions: ^Region, tileSize: Size, numRegions: ^NS.Object) { +Device_convertSparseTileRegions :: #force_inline proc(self: ^Device, tileRegions: ^Region, pixelRegions: ^Region, tileSize: Size, numRegions: ^NS.Object) { msgSend(nil, self, "convertSparseTileRegions:toPixelRegions:withTileSize:numRegions:", tileRegions, pixelRegions, tileSize, numRegions) } @(objc_type=Device, objc_name="counterSets") -Device_counterSets :: proc(self: ^Device) -> ^NS.Array { +Device_counterSets :: #force_inline proc(self: ^Device) -> ^NS.Array { return msgSend(^NS.Array, self, "counterSets") } @(objc_type=Device, objc_name="currentAllocatedSize") -Device_currentAllocatedSize :: proc(self: ^Device) -> NS.Integer { +Device_currentAllocatedSize :: #force_inline proc(self: ^Device) -> NS.Integer { return msgSend(NS.Integer, self, "currentAllocatedSize") } @(objc_type=Device, objc_name="getDefaultSamplePositions") -Device_getDefaultSamplePositions :: proc(self: ^Device, positions: ^SamplePosition, count: ^NS.Object) { +Device_getDefaultSamplePositions :: #force_inline proc(self: ^Device, positions: ^SamplePosition, count: ^NS.Object) { msgSend(nil, self, "getDefaultSamplePositions:count:", positions, count) } @(objc_type=Device, objc_name="hasUnifiedMemory") -Device_hasUnifiedMemory :: proc(self: ^Device) -> BOOL { +Device_hasUnifiedMemory :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "hasUnifiedMemory") } @(objc_type=Device, objc_name="heapBufferSizeAndAlignWithLength") -Device_heapBufferSizeAndAlignWithLength :: proc(self: ^Device, length: ^NS.Object, options: ResourceOptions) -> SizeAndAlign { +Device_heapBufferSizeAndAlignWithLength :: #force_inline proc(self: ^Device, length: ^NS.Object, options: ResourceOptions) -> SizeAndAlign { return msgSend(SizeAndAlign, self, "heapBufferSizeAndAlignWithLength:options:", length, options) } @(objc_type=Device, objc_name="heapTextureSizeAndAlignWithDescriptor") -Device_heapTextureSizeAndAlignWithDescriptor :: proc(self: ^Device, desc: ^TextureDescriptor) -> SizeAndAlign { +Device_heapTextureSizeAndAlignWithDescriptor :: #force_inline proc(self: ^Device, desc: ^TextureDescriptor) -> SizeAndAlign { return msgSend(SizeAndAlign, self, "heapTextureSizeAndAlignWithDescriptor:", desc) } @(objc_type=Device, objc_name="isDepth24Stencil8PixelFormatSupported") -Device_isDepth24Stencil8PixelFormatSupported :: proc(self: ^Device) -> BOOL { +Device_isDepth24Stencil8PixelFormatSupported :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "isDepth24Stencil8PixelFormatSupported") } @(objc_type=Device, objc_name="isHeadless") -Device_isHeadless :: proc(self: ^Device) -> BOOL { +Device_isHeadless :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "isHeadless") } @(objc_type=Device, objc_name="isLowPower") -Device_isLowPower :: proc(self: ^Device) -> BOOL { +Device_isLowPower :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "isLowPower") } @(objc_type=Device, objc_name="isRemovable") -Device_isRemovable :: proc(self: ^Device) -> BOOL { +Device_isRemovable :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "isRemovable") } @(objc_type=Device, objc_name="location") -Device_location :: proc(self: ^Device) -> DeviceLocation { +Device_location :: #force_inline proc(self: ^Device) -> DeviceLocation { return msgSend(DeviceLocation, self, "location") } @(objc_type=Device, objc_name="locationNumber") -Device_locationNumber :: proc(self: ^Device) -> NS.Integer { +Device_locationNumber :: #force_inline proc(self: ^Device) -> NS.Integer { return msgSend(NS.Integer, self, "locationNumber") } @(objc_type=Device, objc_name="maxArgumentBufferSamplerCount") -Device_maxArgumentBufferSamplerCount :: proc(self: ^Device) -> NS.Integer { +Device_maxArgumentBufferSamplerCount :: #force_inline proc(self: ^Device) -> NS.Integer { return msgSend(NS.Integer, self, "maxArgumentBufferSamplerCount") } @(objc_type=Device, objc_name="maxBufferLength") -Device_maxBufferLength :: proc(self: ^Device) -> NS.Integer { +Device_maxBufferLength :: #force_inline proc(self: ^Device) -> NS.Integer { return msgSend(NS.Integer, self, "maxBufferLength") } @(objc_type=Device, objc_name="maxThreadgroupMemoryLength") -Device_maxThreadgroupMemoryLength :: proc(self: ^Device) -> NS.Integer { +Device_maxThreadgroupMemoryLength :: #force_inline proc(self: ^Device) -> NS.Integer { return msgSend(NS.Integer, self, "maxThreadgroupMemoryLength") } @(objc_type=Device, objc_name="maxThreadsPerThreadgroup") -Device_maxThreadsPerThreadgroup :: proc(self: ^Device) -> Size { +Device_maxThreadsPerThreadgroup :: #force_inline proc(self: ^Device) -> Size { return msgSend(Size, self, "maxThreadsPerThreadgroup") } @(objc_type=Device, objc_name="maxTransferRate") -Device_maxTransferRate :: proc(self: ^Device) -> u64 { +Device_maxTransferRate :: #force_inline proc(self: ^Device) -> u64 { return msgSend(u64, self, "maxTransferRate") } @(objc_type=Device, objc_name="minimumLinearTextureAlignmentForPixelFormat") -Device_minimumLinearTextureAlignmentForPixelFormat :: proc(self: ^Device, format: PixelFormat) -> ^Device { +Device_minimumLinearTextureAlignmentForPixelFormat :: #force_inline proc(self: ^Device, format: PixelFormat) -> ^Device { return msgSend(^Device, self, "minimumLinearTextureAlignmentForPixelFormat:", format) } @(objc_type=Device, objc_name="minimumTextureBufferAlignmentForPixelFormat") -Device_minimumTextureBufferAlignmentForPixelFormat :: proc(self: ^Device, format: PixelFormat) -> ^Device { +Device_minimumTextureBufferAlignmentForPixelFormat :: #force_inline proc(self: ^Device, format: PixelFormat) -> ^Device { return msgSend(^Device, self, "minimumTextureBufferAlignmentForPixelFormat:", format) } @(objc_type=Device, objc_name="name") -Device_name :: proc(self: ^Device) -> ^NS.String { +Device_name :: #force_inline proc(self: ^Device) -> ^NS.String { return msgSend(^NS.String, self, "name") } @(objc_type=Device, objc_name="newAccelerationStructureWithDescriptor") -Device_newAccelerationStructureWithDescriptor :: proc(self: ^Device, descriptor: ^AccelerationStructureDescriptor) -> ^Device { +Device_newAccelerationStructureWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^AccelerationStructureDescriptor) -> ^Device { return msgSend(^Device, self, "newAccelerationStructureWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newAccelerationStructureWithSize") -Device_newAccelerationStructureWithSize :: proc(self: ^Device, size: ^NS.Object) -> ^Device { +Device_newAccelerationStructureWithSize :: #force_inline proc(self: ^Device, size: ^NS.Object) -> ^Device { return msgSend(^Device, self, "newAccelerationStructureWithSize:", size) } @(objc_type=Device, objc_name="newArgumentEncoderWithArguments") -Device_newArgumentEncoderWithArguments :: proc(self: ^Device, arguments: ^NS.Array) -> ^Device { +Device_newArgumentEncoderWithArguments :: #force_inline proc(self: ^Device, arguments: ^NS.Array) -> ^Device { return msgSend(^Device, self, "newArgumentEncoderWithArguments:", arguments) } @(objc_type=Device, objc_name="newBinaryArchiveWithDescriptor") -Device_newBinaryArchiveWithDescriptor :: proc(self: ^Device, descriptor: ^BinaryArchiveDescriptor, error: ^^NS.Error ) -> ^Device { +Device_newBinaryArchiveWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^BinaryArchiveDescriptor, error: ^^NS.Error ) -> ^Device { return msgSend(^Device, self, "newBinaryArchiveWithDescriptor:error:", descriptor, error) } @(objc_type=Device, objc_name="newBufferWithBytes") -Device_newBufferWithBytes :: proc(self: ^Device, pointer: rawptr, length: ^NS.Object, options: ResourceOptions) -> ^Device { +Device_newBufferWithBytes :: #force_inline proc(self: ^Device, pointer: rawptr, length: ^NS.Object, options: ResourceOptions) -> ^Device { return msgSend(^Device, self, "newBufferWithBytes:length:options:", pointer, length, options) } @(objc_type=Device, objc_name="newBufferWithBytesNoCopy") -Device_newBufferWithBytesNoCopy :: proc(self: ^Device, pointer: rawptr, length: ^NS.Object, options: ResourceOptions, deallocator: rawptr) -> ^Device { +Device_newBufferWithBytesNoCopy :: #force_inline proc(self: ^Device, pointer: rawptr, length: ^NS.Object, options: ResourceOptions, deallocator: rawptr) -> ^Device { return msgSend(^Device, self, "newBufferWithBytesNoCopy:length:options:deallocator:", pointer, length, options, deallocator) } @(objc_type=Device, objc_name="newBufferWithLength") -Device_newBufferWithLength :: proc(self: ^Device, length: ^NS.Object, options: ResourceOptions) -> ^Device { +Device_newBufferWithLength :: #force_inline proc(self: ^Device, length: ^NS.Object, options: ResourceOptions) -> ^Device { return msgSend(^Device, self, "newBufferWithLength:options:", length, options) } @(objc_type=Device, objc_name="newCommandQueue") -Device_newCommandQueue :: proc(self: ^Device) -> ^Device { +Device_newCommandQueue :: #force_inline proc(self: ^Device) -> ^Device { return msgSend(^Device, self, "newCommandQueue") } @(objc_type=Device, objc_name="newCommandQueueWithMaxCommandBufferCount") -Device_newCommandQueueWithMaxCommandBufferCount :: proc(self: ^Device, maxCommandBufferCount: ^NS.Object) -> ^Device { +Device_newCommandQueueWithMaxCommandBufferCount :: #force_inline proc(self: ^Device, maxCommandBufferCount: ^NS.Object) -> ^Device { return msgSend(^Device, self, "newCommandQueueWithMaxCommandBufferCount:", maxCommandBufferCount) } @(objc_type=Device, objc_name="newComputePipelineStateWithDescriptor_options_completionHandler_") -Device_newComputePipelineStateWithDescriptor_options_completionHandler_ :: proc(self: ^Device, descriptor: ^ComputePipelineDescriptor, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) { +Device_newComputePipelineStateWithDescriptor_options_completionHandler_ :: #force_inline proc(self: ^Device, descriptor: ^ComputePipelineDescriptor, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) { msgSend(nil, self, "newComputePipelineStateWithDescriptor:options:completionHandler:", descriptor, options, completionHandler) } @(objc_type=Device, objc_name="newComputePipelineStateWithDescriptor_options_reflection_error_") -Device_newComputePipelineStateWithDescriptor_options_reflection_error_ :: proc(self: ^Device, descriptor: ^ComputePipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection, error: ^^NS.Error ) -> ^Device { +Device_newComputePipelineStateWithDescriptor_options_reflection_error_ :: #force_inline proc(self: ^Device, descriptor: ^ComputePipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection, error: ^^NS.Error ) -> ^Device { return msgSend(^Device, self, "newComputePipelineStateWithDescriptor:options:reflection:error:", descriptor, options, reflection, error) } @(objc_type=Device, objc_name="newComputePipelineStateWithFunction_completionHandler_") -Device_newComputePipelineStateWithFunction_completionHandler_ :: proc(self: ^Device, computeFunction: ^NS.Object, completionHandler: NewComputePipelineStateCompletionHandler) { +Device_newComputePipelineStateWithFunction_completionHandler_ :: #force_inline proc(self: ^Device, computeFunction: ^NS.Object, completionHandler: NewComputePipelineStateCompletionHandler) { msgSend(nil, self, "newComputePipelineStateWithFunction:completionHandler:", computeFunction, completionHandler) } @(objc_type=Device, objc_name="newComputePipelineStateWithFunction_error_") -Device_newComputePipelineStateWithFunction_error_ :: proc(self: ^Device, computeFunction: ^NS.Object, error: ^^NS.Error ) -> ^Device { +Device_newComputePipelineStateWithFunction_error_ :: #force_inline proc(self: ^Device, computeFunction: ^NS.Object, error: ^^NS.Error ) -> ^Device { return msgSend(^Device, self, "newComputePipelineStateWithFunction:error:", computeFunction, error) } @(objc_type=Device, objc_name="newComputePipelineStateWithFunction_options_completionHandler_") -Device_newComputePipelineStateWithFunction_options_completionHandler_ :: proc(self: ^Device, computeFunction: ^NS.Object, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) { +Device_newComputePipelineStateWithFunction_options_completionHandler_ :: #force_inline proc(self: ^Device, computeFunction: ^NS.Object, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) { msgSend(nil, self, "newComputePipelineStateWithFunction:options:completionHandler:", computeFunction, options, completionHandler) } @(objc_type=Device, objc_name="newComputePipelineStateWithFunction_options_reflection_error_") -Device_newComputePipelineStateWithFunction_options_reflection_error_ :: proc(self: ^Device, computeFunction: ^NS.Object, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection, error: ^^NS.Error ) -> ^Device { +Device_newComputePipelineStateWithFunction_options_reflection_error_ :: #force_inline proc(self: ^Device, computeFunction: ^NS.Object, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection, error: ^^NS.Error ) -> ^Device { return msgSend(^Device, self, "newComputePipelineStateWithFunction:options:reflection:error:", computeFunction, options, reflection, error) } @(objc_type=Device, objc_name="newCounterSampleBufferWithDescriptor") -Device_newCounterSampleBufferWithDescriptor :: proc(self: ^Device, descriptor: ^CounterSampleBufferDescriptor, error: ^^NS.Error ) -> ^Device { +Device_newCounterSampleBufferWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^CounterSampleBufferDescriptor, error: ^^NS.Error ) -> ^Device { return msgSend(^Device, self, "newCounterSampleBufferWithDescriptor:error:", descriptor, error) } @(objc_type=Device, objc_name="newDefaultLibrary") -Device_newDefaultLibrary :: proc(self: ^Device) -> ^Device { +Device_newDefaultLibrary :: #force_inline proc(self: ^Device) -> ^Device { return msgSend(^Device, self, "newDefaultLibrary") } @(objc_type=Device, objc_name="newDefaultLibraryWithBundle") -Device_newDefaultLibraryWithBundle :: proc(self: ^Device, bundle: ^NS.Bundle, error: ^^NS.Error ) -> ^Device { +Device_newDefaultLibraryWithBundle :: #force_inline proc(self: ^Device, bundle: ^NS.Bundle, error: ^^NS.Error ) -> ^Device { return msgSend(^Device, self, "newDefaultLibraryWithBundle:error:", bundle, error) } @(objc_type=Device, objc_name="newDepthStencilStateWithDescriptor") -Device_newDepthStencilStateWithDescriptor :: proc(self: ^Device, descriptor: ^DepthStencilDescriptor) -> ^Device { +Device_newDepthStencilStateWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^DepthStencilDescriptor) -> ^Device { return msgSend(^Device, self, "newDepthStencilStateWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newDynamicLibrary") -Device_newDynamicLibrary :: proc(self: ^Device, library: ^NS.Object, error: ^^NS.Error ) -> ^Device { +Device_newDynamicLibrary :: #force_inline proc(self: ^Device, library: ^NS.Object, error: ^^NS.Error ) -> ^Device { return msgSend(^Device, self, "newDynamicLibrary:error:", library, error) } @(objc_type=Device, objc_name="newDynamicLibraryWithURL") -Device_newDynamicLibraryWithURL :: proc(self: ^Device, url: ^NS.URL, error: ^^NS.Error ) -> ^Device { +Device_newDynamicLibraryWithURL :: #force_inline proc(self: ^Device, url: ^NS.URL, error: ^^NS.Error ) -> ^Device { return msgSend(^Device, self, "newDynamicLibraryWithURL:error:", url, error) } @(objc_type=Device, objc_name="newEvent") -Device_newEvent :: proc(self: ^Device) -> ^Device { +Device_newEvent :: #force_inline proc(self: ^Device) -> ^Device { return msgSend(^Device, self, "newEvent") } @(objc_type=Device, objc_name="newFence") -Device_newFence :: proc(self: ^Device) -> ^Device { +Device_newFence :: #force_inline proc(self: ^Device) -> ^Device { return msgSend(^Device, self, "newFence") } @(objc_type=Device, objc_name="newHeapWithDescriptor") -Device_newHeapWithDescriptor :: proc(self: ^Device, descriptor: ^HeapDescriptor) -> ^Device { +Device_newHeapWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^HeapDescriptor) -> ^Device { return msgSend(^Device, self, "newHeapWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newIndirectCommandBufferWithDescriptor") -Device_newIndirectCommandBufferWithDescriptor :: proc(self: ^Device, descriptor: ^IndirectCommandBufferDescriptor, maxCount: ^NS.Object, options: ResourceOptions) -> ^Device { +Device_newIndirectCommandBufferWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^IndirectCommandBufferDescriptor, maxCount: ^NS.Object, options: ResourceOptions) -> ^Device { return msgSend(^Device, self, "newIndirectCommandBufferWithDescriptor:maxCommandCount:options:", descriptor, maxCount, options) } @(objc_type=Device, objc_name="newLibraryWithData") -Device_newLibraryWithData :: proc(self: ^Device, data: ^NS.Object, error: ^^NS.Error ) -> ^Device { +Device_newLibraryWithData :: #force_inline proc(self: ^Device, data: ^NS.Object, error: ^^NS.Error ) -> ^Device { return msgSend(^Device, self, "newLibraryWithData:error:", data, error) } @(objc_type=Device, objc_name="newLibraryWithFile") -Device_newLibraryWithFile :: proc(self: ^Device, filepath: ^NS.String, error: ^^NS.Error ) -> ^Device { +Device_newLibraryWithFile :: #force_inline proc(self: ^Device, filepath: ^NS.String, error: ^^NS.Error ) -> ^Device { return msgSend(^Device, self, "newLibraryWithFile:error:", filepath, error) } @(objc_type=Device, objc_name="newLibraryWithSource_options_completionHandler_") -Device_newLibraryWithSource_options_completionHandler_ :: proc(self: ^Device, source: ^NS.String, options: ^CompileOptions, completionHandler: NewLibraryCompletionHandler) { +Device_newLibraryWithSource_options_completionHandler_ :: #force_inline proc(self: ^Device, source: ^NS.String, options: ^CompileOptions, completionHandler: NewLibraryCompletionHandler) { msgSend(nil, self, "newLibraryWithSource:options:completionHandler:", source, options, completionHandler) } @(objc_type=Device, objc_name="newLibraryWithSource_options_error_") -Device_newLibraryWithSource_options_error_ :: proc(self: ^Device, source: ^NS.String, options: ^CompileOptions, error: ^^NS.Error ) -> ^Device { +Device_newLibraryWithSource_options_error_ :: #force_inline proc(self: ^Device, source: ^NS.String, options: ^CompileOptions, error: ^^NS.Error ) -> ^Device { return msgSend(^Device, self, "newLibraryWithSource:options:error:", source, options, error) } @(objc_type=Device, objc_name="newLibraryWithURL") -Device_newLibraryWithURL :: proc(self: ^Device, url: ^NS.URL, error: ^^NS.Error ) -> ^Device { +Device_newLibraryWithURL :: #force_inline proc(self: ^Device, url: ^NS.URL, error: ^^NS.Error ) -> ^Device { return msgSend(^Device, self, "newLibraryWithURL:error:", url, error) } @(objc_type=Device, objc_name="newRasterizationRateMapWithDescriptor") -Device_newRasterizationRateMapWithDescriptor :: proc(self: ^Device, descriptor: ^RasterizationRateMapDescriptor) -> ^Device { +Device_newRasterizationRateMapWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^RasterizationRateMapDescriptor) -> ^Device { return msgSend(^Device, self, "newRasterizationRateMapWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor_completionHandler_") -Device_newRenderPipelineStateWithDescriptor_completionHandler_ :: proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, completionHandler: NewRenderPipelineStateCompletionHandler) { +Device_newRenderPipelineStateWithDescriptor_completionHandler_ :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, completionHandler: NewRenderPipelineStateCompletionHandler) { msgSend(nil, self, "newRenderPipelineStateWithDescriptor:completionHandler:", descriptor, completionHandler) } @(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor_error_") -Device_newRenderPipelineStateWithDescriptor_error_ :: proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, error: ^^NS.Error ) -> ^Device { +Device_newRenderPipelineStateWithDescriptor_error_ :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, error: ^^NS.Error ) -> ^Device { return msgSend(^Device, self, "newRenderPipelineStateWithDescriptor:error:", descriptor, error) } @(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor_options_completionHandler_") -Device_newRenderPipelineStateWithDescriptor_options_completionHandler_ :: proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, completionHandler: NewRenderPipelineStateWithReflectionCompletionHandler) { +Device_newRenderPipelineStateWithDescriptor_options_completionHandler_ :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, completionHandler: NewRenderPipelineStateWithReflectionCompletionHandler) { msgSend(nil, self, "newRenderPipelineStateWithDescriptor:options:completionHandler:", descriptor, options, completionHandler) } @(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor_options_reflection_error_") -Device_newRenderPipelineStateWithDescriptor_options_reflection_error_ :: proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection, error: ^^NS.Error ) -> ^Device { +Device_newRenderPipelineStateWithDescriptor_options_reflection_error_ :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection, error: ^^NS.Error ) -> ^Device { return msgSend(^Device, self, "newRenderPipelineStateWithDescriptor:options:reflection:error:", descriptor, options, reflection, error) } @(objc_type=Device, objc_name="newRenderPipelineStateWithTileDescriptor_options_completionHandler_") -Device_newRenderPipelineStateWithTileDescriptor_options_completionHandler_ :: proc(self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, completionHandler: NewRenderPipelineStateWithReflectionCompletionHandler) { +Device_newRenderPipelineStateWithTileDescriptor_options_completionHandler_ :: #force_inline proc(self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, completionHandler: NewRenderPipelineStateWithReflectionCompletionHandler) { msgSend(nil, self, "newRenderPipelineStateWithTileDescriptor:options:completionHandler:", descriptor, options, completionHandler) } @(objc_type=Device, objc_name="newRenderPipelineStateWithTileDescriptor_options_reflection_error_") -Device_newRenderPipelineStateWithTileDescriptor_options_reflection_error_ :: proc(self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection, error: ^^NS.Error ) -> ^Device { +Device_newRenderPipelineStateWithTileDescriptor_options_reflection_error_ :: #force_inline proc(self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection, error: ^^NS.Error ) -> ^Device { return msgSend(^Device, self, "newRenderPipelineStateWithTileDescriptor:options:reflection:error:", descriptor, options, reflection, error) } @(objc_type=Device, objc_name="newSamplerStateWithDescriptor") -Device_newSamplerStateWithDescriptor :: proc(self: ^Device, descriptor: ^SamplerDescriptor) -> ^Device { +Device_newSamplerStateWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^SamplerDescriptor) -> ^Device { return msgSend(^Device, self, "newSamplerStateWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newSharedEvent") -Device_newSharedEvent :: proc(self: ^Device) -> ^Device { +Device_newSharedEvent :: #force_inline proc(self: ^Device) -> ^Device { return msgSend(^Device, self, "newSharedEvent") } @(objc_type=Device, objc_name="newSharedEventWithHandle") -Device_newSharedEventWithHandle :: proc(self: ^Device, sharedEventHandle: ^SharedEventHandle) -> ^Device { +Device_newSharedEventWithHandle :: #force_inline proc(self: ^Device, sharedEventHandle: ^SharedEventHandle) -> ^Device { return msgSend(^Device, self, "newSharedEventWithHandle:", sharedEventHandle) } @(objc_type=Device, objc_name="newSharedTextureWithDescriptor") -Device_newSharedTextureWithDescriptor :: proc(self: ^Device, descriptor: ^TextureDescriptor) -> ^Device { +Device_newSharedTextureWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^TextureDescriptor) -> ^Device { return msgSend(^Device, self, "newSharedTextureWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newSharedTextureWithHandle") -Device_newSharedTextureWithHandle :: proc(self: ^Device, sharedHandle: ^SharedTextureHandle) -> ^Device { +Device_newSharedTextureWithHandle :: #force_inline proc(self: ^Device, sharedHandle: ^SharedTextureHandle) -> ^Device { return msgSend(^Device, self, "newSharedTextureWithHandle:", sharedHandle) } @(objc_type=Device, objc_name="newTextureWithDescriptor") -Device_newTextureWithDescriptor :: proc(self: ^Device, desc: ^TextureDescriptor) -> ^Device { +Device_newTextureWithDescriptor :: #force_inline proc(self: ^Device, desc: ^TextureDescriptor) -> ^Device { return msgSend(^Device, self, "newTextureWithDescriptor:", desc) } @(objc_type=Device, objc_name="newTextureWithDescriptor_iosurface_plane_") -Device_newTextureWithDescriptor_iosurface_plane_ :: proc(self: ^Device, descriptor: ^TextureDescriptor, iosurface: IOSurfaceRef, plane: ^NS.Object) -> ^Device { +Device_newTextureWithDescriptor_iosurface_plane_ :: #force_inline proc(self: ^Device, descriptor: ^TextureDescriptor, iosurface: IOSurfaceRef, plane: ^NS.Object) -> ^Device { return msgSend(^Device, self, "newTextureWithDescriptor:iosurface:plane:", descriptor, iosurface, plane) } @(objc_type=Device, objc_name="peerCount") -Device_peerCount :: proc(self: ^Device) -> u32 { +Device_peerCount :: #force_inline proc(self: ^Device) -> u32 { return msgSend(u32, self, "peerCount") } @(objc_type=Device, objc_name="peerGroupID") -Device_peerGroupID :: proc(self: ^Device) -> u64 { +Device_peerGroupID :: #force_inline proc(self: ^Device) -> u64 { return msgSend(u64, self, "peerGroupID") } @(objc_type=Device, objc_name="peerIndex") -Device_peerIndex :: proc(self: ^Device) -> u32 { +Device_peerIndex :: #force_inline proc(self: ^Device) -> u32 { return msgSend(u32, self, "peerIndex") } @(objc_type=Device, objc_name="readWriteTextureSupport") -Device_readWriteTextureSupport :: proc(self: ^Device) -> ReadWriteTextureTier { +Device_readWriteTextureSupport :: #force_inline proc(self: ^Device) -> ReadWriteTextureTier { return msgSend(ReadWriteTextureTier, self, "readWriteTextureSupport") } @(objc_type=Device, objc_name="recommendedMaxWorkingSetSize") -Device_recommendedMaxWorkingSetSize :: proc(self: ^Device) -> u64 { +Device_recommendedMaxWorkingSetSize :: #force_inline proc(self: ^Device) -> u64 { return msgSend(u64, self, "recommendedMaxWorkingSetSize") } @(objc_type=Device, objc_name="registryID") -Device_registryID :: proc(self: ^Device) -> u64 { +Device_registryID :: #force_inline proc(self: ^Device) -> u64 { return msgSend(u64, self, "registryID") } @(objc_type=Device, objc_name="sampleTimestamps") -Device_sampleTimestamps :: proc(self: ^Device, cpuTimestamp: ^Timestamp, gpuTimestamp: ^Timestamp) { +Device_sampleTimestamps :: #force_inline proc(self: ^Device, cpuTimestamp: ^Timestamp, gpuTimestamp: ^Timestamp) { msgSend(nil, self, "sampleTimestamps:gpuTimestamp:", cpuTimestamp, gpuTimestamp) } @(objc_type=Device, objc_name="sparseTileSizeInBytes") -Device_sparseTileSizeInBytes :: proc(self: ^Device) -> NS.Integer { +Device_sparseTileSizeInBytes :: #force_inline proc(self: ^Device) -> NS.Integer { return msgSend(NS.Integer, self, "sparseTileSizeInBytes") } @(objc_type=Device, objc_name="sparseTileSizeWithTextureType") -Device_sparseTileSizeWithTextureType :: proc(self: ^Device, textureType: TextureType, pixelFormat: PixelFormat, sampleCount: ^NS.Object) -> Size { +Device_sparseTileSizeWithTextureType :: #force_inline proc(self: ^Device, textureType: TextureType, pixelFormat: PixelFormat, sampleCount: ^NS.Object) -> Size { return msgSend(Size, self, "sparseTileSizeWithTextureType:pixelFormat:sampleCount:", textureType, pixelFormat, sampleCount) } @(objc_type=Device, objc_name="supports32BitFloatFiltering") -Device_supports32BitFloatFiltering :: proc(self: ^Device) -> BOOL { +Device_supports32BitFloatFiltering :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "supports32BitFloatFiltering") } @(objc_type=Device, objc_name="supports32BitMSAA") -Device_supports32BitMSAA :: proc(self: ^Device) -> BOOL { +Device_supports32BitMSAA :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "supports32BitMSAA") } @(objc_type=Device, objc_name="supportsBCTextureCompression") -Device_supportsBCTextureCompression :: proc(self: ^Device) -> BOOL { +Device_supportsBCTextureCompression :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "supportsBCTextureCompression") } @(objc_type=Device, objc_name="supportsCounterSampling") -Device_supportsCounterSampling :: proc(self: ^Device, samplingPoint: CounterSamplingPoint) -> BOOL { +Device_supportsCounterSampling :: #force_inline proc(self: ^Device, samplingPoint: CounterSamplingPoint) -> BOOL { return msgSend(BOOL, self, "supportsCounterSampling:", samplingPoint) } @(objc_type=Device, objc_name="supportsDynamicLibraries") -Device_supportsDynamicLibraries :: proc(self: ^Device) -> BOOL { +Device_supportsDynamicLibraries :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "supportsDynamicLibraries") } @(objc_type=Device, objc_name="supportsFamily") -Device_supportsFamily :: proc(self: ^Device, gpuFamily: GPUFamily) -> BOOL { +Device_supportsFamily :: #force_inline proc(self: ^Device, gpuFamily: GPUFamily) -> BOOL { return msgSend(BOOL, self, "supportsFamily:", gpuFamily) } @(objc_type=Device, objc_name="supportsFeatureSet") -Device_supportsFeatureSet :: proc(self: ^Device, featureSet: FeatureSet) -> BOOL { +Device_supportsFeatureSet :: #force_inline proc(self: ^Device, featureSet: FeatureSet) -> BOOL { return msgSend(BOOL, self, "supportsFeatureSet:", featureSet) } @(objc_type=Device, objc_name="supportsFunctionPointers") -Device_supportsFunctionPointers :: proc(self: ^Device) -> BOOL { +Device_supportsFunctionPointers :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "supportsFunctionPointers") } @(objc_type=Device, objc_name="supportsPullModelInterpolation") -Device_supportsPullModelInterpolation :: proc(self: ^Device) -> BOOL { +Device_supportsPullModelInterpolation :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "supportsPullModelInterpolation") } @(objc_type=Device, objc_name="supportsQueryTextureLOD") -Device_supportsQueryTextureLOD :: proc(self: ^Device) -> BOOL { +Device_supportsQueryTextureLOD :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "supportsQueryTextureLOD") } @(objc_type=Device, objc_name="supportsRasterizationRateMapWithLayerCount") -Device_supportsRasterizationRateMapWithLayerCount :: proc(self: ^Device, layerCount: ^NS.Object) -> BOOL { +Device_supportsRasterizationRateMapWithLayerCount :: #force_inline proc(self: ^Device, layerCount: ^NS.Object) -> BOOL { return msgSend(BOOL, self, "supportsRasterizationRateMapWithLayerCount:", layerCount) } @(objc_type=Device, objc_name="supportsRaytracing") -Device_supportsRaytracing :: proc(self: ^Device) -> BOOL { +Device_supportsRaytracing :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "supportsRaytracing") } @(objc_type=Device, objc_name="supportsShaderBarycentricCoordinates") -Device_supportsShaderBarycentricCoordinates :: proc(self: ^Device) -> BOOL { +Device_supportsShaderBarycentricCoordinates :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "supportsShaderBarycentricCoordinates") } @(objc_type=Device, objc_name="supportsTextureSampleCount") -Device_supportsTextureSampleCount :: proc(self: ^Device, sampleCount: ^NS.Object) -> BOOL { +Device_supportsTextureSampleCount :: #force_inline proc(self: ^Device, sampleCount: ^NS.Object) -> BOOL { return msgSend(BOOL, self, "supportsTextureSampleCount:", sampleCount) } @(objc_type=Device, objc_name="supportsVertexAmplificationCount") -Device_supportsVertexAmplificationCount :: proc(self: ^Device, count: ^NS.Object) -> BOOL { +Device_supportsVertexAmplificationCount :: #force_inline proc(self: ^Device, count: ^NS.Object) -> BOOL { return msgSend(BOOL, self, "supportsVertexAmplificationCount:", count) } @@ -6445,27 +6431,27 @@ Methods: Drawable :: struct { using _: NS.Object } @(objc_type=Drawable, objc_name="addPresentedHandler") -Drawable_addPresentedHandler :: proc(self: ^Drawable, block: DrawablePresentedHandler) { +Drawable_addPresentedHandler :: #force_inline proc(self: ^Drawable, block: DrawablePresentedHandler) { msgSend(nil, self, "addPresentedHandler:", block) } @(objc_type=Drawable, objc_name="drawableID") -Drawable_drawableID :: proc(self: ^Drawable) -> NS.Integer { +Drawable_drawableID :: #force_inline proc(self: ^Drawable) -> NS.Integer { return msgSend(NS.Integer, self, "drawableID") } @(objc_type=Drawable, objc_name="present") -Drawable_present :: proc(self: ^Drawable) { +Drawable_present :: #force_inline proc(self: ^Drawable) { msgSend(nil, self, "present") } @(objc_type=Drawable, objc_name="presentAfterMinimumDuration") -Drawable_presentAfterMinimumDuration :: proc(self: ^Drawable, duration: CFTimeInterval) { +Drawable_presentAfterMinimumDuration :: #force_inline proc(self: ^Drawable, duration: CFTimeInterval) { msgSend(nil, self, "presentAfterMinimumDuration:", duration) } @(objc_type=Drawable, objc_name="presentAtTime") -Drawable_presentAtTime :: proc(self: ^Drawable, presentationTime: CFTimeInterval) { +Drawable_presentAtTime :: #force_inline proc(self: ^Drawable, presentationTime: CFTimeInterval) { msgSend(nil, self, "presentAtTime:", presentationTime) } @(objc_type=Drawable, objc_name="presentedTime") -Drawable_presentedTime :: proc(self: ^Drawable) -> CFTimeInterval { +Drawable_presentedTime :: #force_inline proc(self: ^Drawable) -> CFTimeInterval { return msgSend(CFTimeInterval, self, "presentedTime") } @@ -6486,23 +6472,23 @@ Methods: DynamicLibrary :: struct { using _: NS.Object } @(objc_type=DynamicLibrary, objc_name="device") -DynamicLibrary_device :: proc(self: ^DynamicLibrary) -> ^DynamicLibrary { +DynamicLibrary_device :: #force_inline proc(self: ^DynamicLibrary) -> ^DynamicLibrary { return msgSend(^DynamicLibrary, self, "device") } @(objc_type=DynamicLibrary, objc_name="installName") -DynamicLibrary_installName :: proc(self: ^DynamicLibrary) -> ^NS.String { +DynamicLibrary_installName :: #force_inline proc(self: ^DynamicLibrary) -> ^NS.String { return msgSend(^NS.String, self, "installName") } @(objc_type=DynamicLibrary, objc_name="label") -DynamicLibrary_label :: proc(self: ^DynamicLibrary) -> ^NS.String { +DynamicLibrary_label :: #force_inline proc(self: ^DynamicLibrary) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=DynamicLibrary, objc_name="serializeToURL") -DynamicLibrary_serializeToURL :: proc(self: ^DynamicLibrary, url: ^NS.URL, error: ^^NS.Error ) -> BOOL { +DynamicLibrary_serializeToURL :: #force_inline proc(self: ^DynamicLibrary, url: ^NS.URL, error: ^^NS.Error ) -> BOOL { return msgSend(BOOL, self, "serializeToURL:error:", url, error) } @(objc_type=DynamicLibrary, objc_name="setLabel") -DynamicLibrary_setLabel :: proc(self: ^DynamicLibrary, label: ^NS.String) { +DynamicLibrary_setLabel :: #force_inline proc(self: ^DynamicLibrary, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @@ -6521,15 +6507,15 @@ Methods: Event :: struct { using _: NS.Object } @(objc_type=Event, objc_name="device") -Event_device :: proc(self: ^Event) -> ^Event { +Event_device :: #force_inline proc(self: ^Event) -> ^Event { return msgSend(^Event, self, "device") } @(objc_type=Event, objc_name="label") -Event_label :: proc(self: ^Event) -> ^NS.String { +Event_label :: #force_inline proc(self: ^Event) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=Event, objc_name="setLabel") -Event_setLabel :: proc(self: ^Event, label: ^NS.String) { +Event_setLabel :: #force_inline proc(self: ^Event, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @@ -6548,15 +6534,15 @@ Methods: Fence :: struct { using _: NS.Object } @(objc_type=Fence, objc_name="device") -Fence_device :: proc(self: ^Fence) -> ^Fence { +Fence_device :: #force_inline proc(self: ^Fence) -> ^Fence { return msgSend(^Fence, self, "device") } @(objc_type=Fence, objc_name="label") -Fence_label :: proc(self: ^Fence) -> ^NS.String { +Fence_label :: #force_inline proc(self: ^Fence) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=Fence, objc_name="setLabel") -Fence_setLabel :: proc(self: ^Fence, label: ^NS.String) { +Fence_setLabel :: #force_inline proc(self: ^Fence, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @@ -6585,55 +6571,55 @@ Methods: Function :: struct { using _: NS.Object } @(objc_type=Function, objc_name="device") -Function_device :: proc(self: ^Function) -> ^Function { +Function_device :: #force_inline proc(self: ^Function) -> ^Function { return msgSend(^Function, self, "device") } @(objc_type=Function, objc_name="functionConstantsDictionary") -Function_functionConstantsDictionary :: proc(self: ^Function) -> ^NS.Dictionary { +Function_functionConstantsDictionary :: #force_inline proc(self: ^Function) -> ^NS.Dictionary { return msgSend(^NS.Dictionary, self, "functionConstantsDictionary") } @(objc_type=Function, objc_name="functionType") -Function_functionType :: proc(self: ^Function) -> FunctionType { +Function_functionType :: #force_inline proc(self: ^Function) -> FunctionType { return msgSend(FunctionType, self, "functionType") } @(objc_type=Function, objc_name="label") -Function_label :: proc(self: ^Function) -> ^NS.String { +Function_label :: #force_inline proc(self: ^Function) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=Function, objc_name="name") -Function_name :: proc(self: ^Function) -> ^NS.String { +Function_name :: #force_inline proc(self: ^Function) -> ^NS.String { return msgSend(^NS.String, self, "name") } @(objc_type=Function, objc_name="newArgumentEncoderWithBufferIndex") -Function_newArgumentEncoderWithBufferIndex :: proc(self: ^Function, bufferIndex: ^NS.Object) -> ^Function { +Function_newArgumentEncoderWithBufferIndex :: #force_inline proc(self: ^Function, bufferIndex: ^NS.Object) -> ^Function { return msgSend(^Function, self, "newArgumentEncoderWithBufferIndex:", bufferIndex) } @(objc_type=Function, objc_name="newArgumentEncoderWithBufferIndex_reflection_") -Function_newArgumentEncoderWithBufferIndex_reflection_ :: proc(self: ^Function, bufferIndex: ^NS.Object, reflection: ^AutoreleasedArgument) -> ^Function { +Function_newArgumentEncoderWithBufferIndex_reflection_ :: #force_inline proc(self: ^Function, bufferIndex: ^NS.Object, reflection: ^AutoreleasedArgument) -> ^Function { return msgSend(^Function, self, "newArgumentEncoderWithBufferIndex:reflection:", bufferIndex, reflection) } @(objc_type=Function, objc_name="options") -Function_options :: proc(self: ^Function) -> FunctionOptions { +Function_options :: #force_inline proc(self: ^Function) -> FunctionOptions { return msgSend(FunctionOptions, self, "options") } @(objc_type=Function, objc_name="patchControlPointCount") -Function_patchControlPointCount :: proc(self: ^Function) -> NS.Integer { +Function_patchControlPointCount :: #force_inline proc(self: ^Function) -> NS.Integer { return msgSend(NS.Integer, self, "patchControlPointCount") } @(objc_type=Function, objc_name="patchType") -Function_patchType :: proc(self: ^Function) -> PatchType { +Function_patchType :: #force_inline proc(self: ^Function) -> PatchType { return msgSend(PatchType, self, "patchType") } @(objc_type=Function, objc_name="setLabel") -Function_setLabel :: proc(self: ^Function, label: ^NS.String) { +Function_setLabel :: #force_inline proc(self: ^Function, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=Function, objc_name="stageInputAttributes") -Function_stageInputAttributes :: proc(self: ^Function) -> ^NS.Array { +Function_stageInputAttributes :: #force_inline proc(self: ^Function) -> ^NS.Array { return msgSend(^NS.Array, self, "stageInputAttributes") } @(objc_type=Function, objc_name="vertexAttributes") -Function_vertexAttributes :: proc(self: ^Function) -> ^NS.Array { +Function_vertexAttributes :: #force_inline proc(self: ^Function) -> ^NS.Array { return msgSend(^NS.Array, self, "vertexAttributes") } @@ -6652,15 +6638,15 @@ Methods: FunctionHandle :: struct { using _: NS.Object } @(objc_type=FunctionHandle, objc_name="device") -FunctionHandle_device :: proc(self: ^FunctionHandle) -> ^FunctionHandle { +FunctionHandle_device :: #force_inline proc(self: ^FunctionHandle) -> ^FunctionHandle { return msgSend(^FunctionHandle, self, "device") } @(objc_type=FunctionHandle, objc_name="functionType") -FunctionHandle_functionType :: proc(self: ^FunctionHandle) -> FunctionType { +FunctionHandle_functionType :: #force_inline proc(self: ^FunctionHandle) -> FunctionType { return msgSend(FunctionType, self, "functionType") } @(objc_type=FunctionHandle, objc_name="name") -FunctionHandle_name :: proc(self: ^FunctionHandle) -> ^NS.String { +FunctionHandle_name :: #force_inline proc(self: ^FunctionHandle) -> ^NS.String { return msgSend(^NS.String, self, "name") } @@ -6680,19 +6666,19 @@ Methods: FunctionLog :: struct { using _: NS.Object } @(objc_type=FunctionLog, objc_name="debugLocation") -FunctionLog_debugLocation :: proc(self: ^FunctionLog) -> ^FunctionLog { +FunctionLog_debugLocation :: #force_inline proc(self: ^FunctionLog) -> ^FunctionLog { return msgSend(^FunctionLog, self, "debugLocation") } @(objc_type=FunctionLog, objc_name="encoderLabel") -FunctionLog_encoderLabel :: proc(self: ^FunctionLog) -> ^NS.String { +FunctionLog_encoderLabel :: #force_inline proc(self: ^FunctionLog) -> ^NS.String { return msgSend(^NS.String, self, "encoderLabel") } @(objc_type=FunctionLog, objc_name="function") -FunctionLog_function :: proc(self: ^FunctionLog) -> ^FunctionLog { +FunctionLog_function :: #force_inline proc(self: ^FunctionLog) -> ^FunctionLog { return msgSend(^FunctionLog, self, "function") } @(objc_type=FunctionLog, objc_name="type") -FunctionLog_type :: proc(self: ^FunctionLog) -> FunctionLogType { +FunctionLog_type :: #force_inline proc(self: ^FunctionLog) -> FunctionLogType { return msgSend(FunctionLogType, self, "type") } @@ -6712,19 +6698,19 @@ Methods: FunctionLogDebugLocation :: struct { using _: NS.Object } @(objc_type=FunctionLogDebugLocation, objc_name="URL") -FunctionLogDebugLocation_URL :: proc(self: ^FunctionLogDebugLocation) -> ^NS.URL { +FunctionLogDebugLocation_URL :: #force_inline proc(self: ^FunctionLogDebugLocation) -> ^NS.URL { return msgSend(^NS.URL, self, "URL") } @(objc_type=FunctionLogDebugLocation, objc_name="column") -FunctionLogDebugLocation_column :: proc(self: ^FunctionLogDebugLocation) -> NS.Integer { +FunctionLogDebugLocation_column :: #force_inline proc(self: ^FunctionLogDebugLocation) -> NS.Integer { return msgSend(NS.Integer, self, "column") } @(objc_type=FunctionLogDebugLocation, objc_name="functionName") -FunctionLogDebugLocation_functionName :: proc(self: ^FunctionLogDebugLocation) -> ^NS.String { +FunctionLogDebugLocation_functionName :: #force_inline proc(self: ^FunctionLogDebugLocation) -> ^NS.String { return msgSend(^NS.String, self, "functionName") } @(objc_type=FunctionLogDebugLocation, objc_name="line") -FunctionLogDebugLocation_line :: proc(self: ^FunctionLogDebugLocation) -> NS.Integer { +FunctionLogDebugLocation_line :: #force_inline proc(self: ^FunctionLogDebugLocation) -> NS.Integer { return msgSend(NS.Integer, self, "line") } @@ -6757,71 +6743,71 @@ Methods: Heap :: struct { using _: NS.Object } @(objc_type=Heap, objc_name="cpuCacheMode") -Heap_cpuCacheMode :: proc(self: ^Heap) -> CPUCacheMode { +Heap_cpuCacheMode :: #force_inline proc(self: ^Heap) -> CPUCacheMode { return msgSend(CPUCacheMode, self, "cpuCacheMode") } @(objc_type=Heap, objc_name="currentAllocatedSize") -Heap_currentAllocatedSize :: proc(self: ^Heap) -> NS.Integer { +Heap_currentAllocatedSize :: #force_inline proc(self: ^Heap) -> NS.Integer { return msgSend(NS.Integer, self, "currentAllocatedSize") } @(objc_type=Heap, objc_name="device") -Heap_device :: proc(self: ^Heap) -> ^Heap { +Heap_device :: #force_inline proc(self: ^Heap) -> ^Heap { return msgSend(^Heap, self, "device") } @(objc_type=Heap, objc_name="hazardTrackingMode") -Heap_hazardTrackingMode :: proc(self: ^Heap) -> HazardTrackingMode { +Heap_hazardTrackingMode :: #force_inline proc(self: ^Heap) -> HazardTrackingMode { return msgSend(HazardTrackingMode, self, "hazardTrackingMode") } @(objc_type=Heap, objc_name="label") -Heap_label :: proc(self: ^Heap) -> ^NS.String { +Heap_label :: #force_inline proc(self: ^Heap) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=Heap, objc_name="maxAvailableSizeWithAlignment") -Heap_maxAvailableSizeWithAlignment :: proc(self: ^Heap, alignment: ^NS.Object) -> ^Heap { +Heap_maxAvailableSizeWithAlignment :: #force_inline proc(self: ^Heap, alignment: ^NS.Object) -> ^Heap { return msgSend(^Heap, self, "maxAvailableSizeWithAlignment:", alignment) } @(objc_type=Heap, objc_name="newBufferWithLength") -Heap_newBufferWithLength :: proc(self: ^Heap, length: ^NS.Object, options: ResourceOptions) -> ^Heap { +Heap_newBufferWithLength :: #force_inline proc(self: ^Heap, length: ^NS.Object, options: ResourceOptions) -> ^Heap { return msgSend(^Heap, self, "newBufferWithLength:options:", length, options) } @(objc_type=Heap, objc_name="newBufferWithLength_options_offset_") -Heap_newBufferWithLength_options_offset_ :: proc(self: ^Heap, length: ^NS.Object, options: ResourceOptions, offset: ^NS.Object) -> ^Heap { +Heap_newBufferWithLength_options_offset_ :: #force_inline proc(self: ^Heap, length: ^NS.Object, options: ResourceOptions, offset: ^NS.Object) -> ^Heap { return msgSend(^Heap, self, "newBufferWithLength:options:offset:", length, options, offset) } @(objc_type=Heap, objc_name="newTextureWithDescriptor") -Heap_newTextureWithDescriptor :: proc(self: ^Heap, desc: ^TextureDescriptor) -> ^Heap { +Heap_newTextureWithDescriptor :: #force_inline proc(self: ^Heap, desc: ^TextureDescriptor) -> ^Heap { return msgSend(^Heap, self, "newTextureWithDescriptor:", desc) } @(objc_type=Heap, objc_name="newTextureWithDescriptor_offset_") -Heap_newTextureWithDescriptor_offset_ :: proc(self: ^Heap, descriptor: ^TextureDescriptor, offset: ^NS.Object) -> ^Heap { +Heap_newTextureWithDescriptor_offset_ :: #force_inline proc(self: ^Heap, descriptor: ^TextureDescriptor, offset: ^NS.Object) -> ^Heap { return msgSend(^Heap, self, "newTextureWithDescriptor:offset:", descriptor, offset) } @(objc_type=Heap, objc_name="resourceOptions") -Heap_resourceOptions :: proc(self: ^Heap) -> ResourceOptions { +Heap_resourceOptions :: #force_inline proc(self: ^Heap) -> ResourceOptions { return msgSend(ResourceOptions, self, "resourceOptions") } @(objc_type=Heap, objc_name="setLabel") -Heap_setLabel :: proc(self: ^Heap, label: ^NS.String) { +Heap_setLabel :: #force_inline proc(self: ^Heap, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=Heap, objc_name="setPurgeableState") -Heap_setPurgeableState :: proc(self: ^Heap, state: PurgeableState) -> PurgeableState { +Heap_setPurgeableState :: #force_inline proc(self: ^Heap, state: PurgeableState) -> PurgeableState { return msgSend(PurgeableState, self, "setPurgeableState:", state) } @(objc_type=Heap, objc_name="size") -Heap_size :: proc(self: ^Heap) -> NS.Integer { +Heap_size :: #force_inline proc(self: ^Heap) -> NS.Integer { return msgSend(NS.Integer, self, "size") } @(objc_type=Heap, objc_name="storageMode") -Heap_storageMode :: proc(self: ^Heap) -> StorageMode { +Heap_storageMode :: #force_inline proc(self: ^Heap) -> StorageMode { return msgSend(StorageMode, self, "storageMode") } @(objc_type=Heap, objc_name="type") -Heap_type :: proc(self: ^Heap) -> FunctionLogType { +Heap_type :: #force_inline proc(self: ^Heap) -> FunctionLogType { return msgSend(FunctionLogType, self, "type") } @(objc_type=Heap, objc_name="usedSize") -Heap_usedSize :: proc(self: ^Heap) -> NS.Integer { +Heap_usedSize :: #force_inline proc(self: ^Heap) -> NS.Integer { return msgSend(NS.Integer, self, "usedSize") } @@ -6841,19 +6827,19 @@ Methods: IndirectCommandBuffer :: struct { using _: NS.Object } @(objc_type=IndirectCommandBuffer, objc_name="indirectComputeCommandAtIndex") -IndirectCommandBuffer_indirectComputeCommandAtIndex :: proc(self: ^IndirectCommandBuffer, commandIndex: ^NS.Object) -> ^IndirectCommandBuffer { +IndirectCommandBuffer_indirectComputeCommandAtIndex :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: ^NS.Object) -> ^IndirectCommandBuffer { return msgSend(^IndirectCommandBuffer, self, "indirectComputeCommandAtIndex:", commandIndex) } @(objc_type=IndirectCommandBuffer, objc_name="indirectRenderCommandAtIndex") -IndirectCommandBuffer_indirectRenderCommandAtIndex :: proc(self: ^IndirectCommandBuffer, commandIndex: ^NS.Object) -> ^IndirectCommandBuffer { +IndirectCommandBuffer_indirectRenderCommandAtIndex :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: ^NS.Object) -> ^IndirectCommandBuffer { return msgSend(^IndirectCommandBuffer, self, "indirectRenderCommandAtIndex:", commandIndex) } @(objc_type=IndirectCommandBuffer, objc_name="resetWithRange") -IndirectCommandBuffer_resetWithRange :: proc(self: ^IndirectCommandBuffer, range: NS.Range) { +IndirectCommandBuffer_resetWithRange :: #force_inline proc(self: ^IndirectCommandBuffer, range: NS.Range) { msgSend(nil, self, "resetWithRange:", range) } @(objc_type=IndirectCommandBuffer, objc_name="size") -IndirectCommandBuffer_size :: proc(self: ^IndirectCommandBuffer) -> NS.Integer { +IndirectCommandBuffer_size :: #force_inline proc(self: ^IndirectCommandBuffer) -> NS.Integer { return msgSend(NS.Integer, self, "size") } @@ -6879,43 +6865,43 @@ Methods: IndirectComputeCommand :: struct { using _: NS.Object } @(objc_type=IndirectComputeCommand, objc_name="clearBarrier") -IndirectComputeCommand_clearBarrier :: proc(self: ^IndirectComputeCommand) { +IndirectComputeCommand_clearBarrier :: #force_inline proc(self: ^IndirectComputeCommand) { msgSend(nil, self, "clearBarrier") } @(objc_type=IndirectComputeCommand, objc_name="concurrentDispatchThreadgroups") -IndirectComputeCommand_concurrentDispatchThreadgroups :: proc(self: ^IndirectComputeCommand, threadgroupsPerGrid: Size, threadsPerThreadgroup: Size) { +IndirectComputeCommand_concurrentDispatchThreadgroups :: #force_inline proc(self: ^IndirectComputeCommand, threadgroupsPerGrid: Size, threadsPerThreadgroup: Size) { msgSend(nil, self, "concurrentDispatchThreadgroups:threadsPerThreadgroup:", threadgroupsPerGrid, threadsPerThreadgroup) } @(objc_type=IndirectComputeCommand, objc_name="concurrentDispatchThreads") -IndirectComputeCommand_concurrentDispatchThreads :: proc(self: ^IndirectComputeCommand, threadsPerGrid: Size, threadsPerThreadgroup: Size) { +IndirectComputeCommand_concurrentDispatchThreads :: #force_inline proc(self: ^IndirectComputeCommand, threadsPerGrid: Size, threadsPerThreadgroup: Size) { msgSend(nil, self, "concurrentDispatchThreads:threadsPerThreadgroup:", threadsPerGrid, threadsPerThreadgroup) } @(objc_type=IndirectComputeCommand, objc_name="reset") -IndirectComputeCommand_reset :: proc(self: ^IndirectComputeCommand) { +IndirectComputeCommand_reset :: #force_inline proc(self: ^IndirectComputeCommand) { msgSend(nil, self, "reset") } @(objc_type=IndirectComputeCommand, objc_name="setBarrier") -IndirectComputeCommand_setBarrier :: proc(self: ^IndirectComputeCommand) { +IndirectComputeCommand_setBarrier :: #force_inline proc(self: ^IndirectComputeCommand) { msgSend(nil, self, "setBarrier") } @(objc_type=IndirectComputeCommand, objc_name="setComputePipelineState") -IndirectComputeCommand_setComputePipelineState :: proc(self: ^IndirectComputeCommand, pipelineState: ^NS.Object) { +IndirectComputeCommand_setComputePipelineState :: #force_inline proc(self: ^IndirectComputeCommand, pipelineState: ^NS.Object) { msgSend(nil, self, "setComputePipelineState:", pipelineState) } @(objc_type=IndirectComputeCommand, objc_name="setImageblockWidth") -IndirectComputeCommand_setImageblockWidth :: proc(self: ^IndirectComputeCommand, width: ^NS.Object, height: ^NS.Object) { +IndirectComputeCommand_setImageblockWidth :: #force_inline proc(self: ^IndirectComputeCommand, width: ^NS.Object, height: ^NS.Object) { msgSend(nil, self, "setImageblockWidth:height:", width, height) } @(objc_type=IndirectComputeCommand, objc_name="setKernelBuffer") -IndirectComputeCommand_setKernelBuffer :: proc(self: ^IndirectComputeCommand, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +IndirectComputeCommand_setKernelBuffer :: #force_inline proc(self: ^IndirectComputeCommand, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setKernelBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=IndirectComputeCommand, objc_name="setStageInRegion") -IndirectComputeCommand_setStageInRegion :: proc(self: ^IndirectComputeCommand, region: Region) { +IndirectComputeCommand_setStageInRegion :: #force_inline proc(self: ^IndirectComputeCommand, region: Region) { msgSend(nil, self, "setStageInRegion:", region) } @(objc_type=IndirectComputeCommand, objc_name="setThreadgroupMemoryLength") -IndirectComputeCommand_setThreadgroupMemoryLength :: proc(self: ^IndirectComputeCommand, length: ^NS.Object, index: ^NS.Object) { +IndirectComputeCommand_setThreadgroupMemoryLength :: #force_inline proc(self: ^IndirectComputeCommand, length: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setThreadgroupMemoryLength:atIndex:", length, index) } @@ -6939,35 +6925,35 @@ Methods: IndirectRenderCommand :: struct { using _: NS.Object } @(objc_type=IndirectRenderCommand, objc_name="drawIndexedPatches") -IndirectRenderCommand_drawIndexedPatches :: proc(self: ^IndirectRenderCommand, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, controlPointIndexBuffer: ^NS.Object, controlPointIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object, buffer: ^NS.Object, offset: ^NS.Object, instanceStride: ^NS.Object) { +IndirectRenderCommand_drawIndexedPatches :: #force_inline proc(self: ^IndirectRenderCommand, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, controlPointIndexBuffer: ^NS.Object, controlPointIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object, buffer: ^NS.Object, offset: ^NS.Object, instanceStride: ^NS.Object) { msgSend(nil, self, "drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride) } @(objc_type=IndirectRenderCommand, objc_name="drawIndexedPrimitives") -IndirectRenderCommand_drawIndexedPrimitives :: proc(self: ^IndirectRenderCommand, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseVertex: ^NS.Object, baseInstance: ^NS.Object) { +IndirectRenderCommand_drawIndexedPrimitives :: #force_inline proc(self: ^IndirectRenderCommand, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseVertex: ^NS.Object, baseInstance: ^NS.Object) { msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount, baseVertex, baseInstance) } @(objc_type=IndirectRenderCommand, objc_name="drawPatches") -IndirectRenderCommand_drawPatches :: proc(self: ^IndirectRenderCommand, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object, buffer: ^NS.Object, offset: ^NS.Object, instanceStride: ^NS.Object) { +IndirectRenderCommand_drawPatches :: #force_inline proc(self: ^IndirectRenderCommand, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object, buffer: ^NS.Object, offset: ^NS.Object, instanceStride: ^NS.Object) { msgSend(nil, self, "drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride) } @(objc_type=IndirectRenderCommand, objc_name="drawPrimitives") -IndirectRenderCommand_drawPrimitives :: proc(self: ^IndirectRenderCommand, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) { +IndirectRenderCommand_drawPrimitives :: #force_inline proc(self: ^IndirectRenderCommand, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) { msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:", primitiveType, vertexStart, vertexCount, instanceCount, baseInstance) } @(objc_type=IndirectRenderCommand, objc_name="reset") -IndirectRenderCommand_reset :: proc(self: ^IndirectRenderCommand) { +IndirectRenderCommand_reset :: #force_inline proc(self: ^IndirectRenderCommand) { msgSend(nil, self, "reset") } @(objc_type=IndirectRenderCommand, objc_name="setFragmentBuffer") -IndirectRenderCommand_setFragmentBuffer :: proc(self: ^IndirectRenderCommand, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +IndirectRenderCommand_setFragmentBuffer :: #force_inline proc(self: ^IndirectRenderCommand, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setFragmentBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=IndirectRenderCommand, objc_name="setRenderPipelineState") -IndirectRenderCommand_setRenderPipelineState :: proc(self: ^IndirectRenderCommand, pipelineState: ^NS.Object) { +IndirectRenderCommand_setRenderPipelineState :: #force_inline proc(self: ^IndirectRenderCommand, pipelineState: ^NS.Object) { msgSend(nil, self, "setRenderPipelineState:", pipelineState) } @(objc_type=IndirectRenderCommand, objc_name="setVertexBuffer") -IndirectRenderCommand_setVertexBuffer :: proc(self: ^IndirectRenderCommand, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +IndirectRenderCommand_setVertexBuffer :: #force_inline proc(self: ^IndirectRenderCommand, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setVertexBuffer:offset:atIndex:", buffer, offset, index) } @@ -6991,35 +6977,35 @@ Methods: IntersectionFunctionTable :: struct { using _: NS.Object } @(objc_type=IntersectionFunctionTable, objc_name="setBuffer") -IntersectionFunctionTable_setBuffer :: proc(self: ^IntersectionFunctionTable, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +IntersectionFunctionTable_setBuffer :: #force_inline proc(self: ^IntersectionFunctionTable, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=IntersectionFunctionTable, objc_name="setBuffers") -IntersectionFunctionTable_setBuffers :: proc(self: ^IntersectionFunctionTable, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { +IntersectionFunctionTable_setBuffers :: #force_inline proc(self: ^IntersectionFunctionTable, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { msgSend(nil, self, "setBuffers:offsets:withRange:", buffers, offsets, range) } @(objc_type=IntersectionFunctionTable, objc_name="setFunction") -IntersectionFunctionTable_setFunction :: proc(self: ^IntersectionFunctionTable, function: ^NS.Object, index: ^NS.Object) { +IntersectionFunctionTable_setFunction :: #force_inline proc(self: ^IntersectionFunctionTable, function: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setFunction:atIndex:", function, index) } @(objc_type=IntersectionFunctionTable, objc_name="setFunctions") -IntersectionFunctionTable_setFunctions :: proc(self: ^IntersectionFunctionTable, functions: ^^NS.Object, range: NS.Range) { +IntersectionFunctionTable_setFunctions :: #force_inline proc(self: ^IntersectionFunctionTable, functions: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setFunctions:withRange:", functions, range) } @(objc_type=IntersectionFunctionTable, objc_name="setOpaqueTriangleIntersectionFunctionWithSignature_atIndex_") -IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignature_atIndex_ :: proc(self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, index: ^NS.Object) { +IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignature_atIndex_ :: #force_inline proc(self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, index: ^NS.Object) { msgSend(nil, self, "setOpaqueTriangleIntersectionFunctionWithSignature:atIndex:", signature, index) } @(objc_type=IntersectionFunctionTable, objc_name="setOpaqueTriangleIntersectionFunctionWithSignature_withRange_") -IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignature_withRange_ :: proc(self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, range: NS.Range) { +IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignature_withRange_ :: #force_inline proc(self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, range: NS.Range) { msgSend(nil, self, "setOpaqueTriangleIntersectionFunctionWithSignature:withRange:", signature, range) } @(objc_type=IntersectionFunctionTable, objc_name="setVisibleFunctionTable") -IntersectionFunctionTable_setVisibleFunctionTable :: proc(self: ^IntersectionFunctionTable, visibleFunctionTable: ^NS.Object, bufferIndex: ^NS.Object) { +IntersectionFunctionTable_setVisibleFunctionTable :: #force_inline proc(self: ^IntersectionFunctionTable, visibleFunctionTable: ^NS.Object, bufferIndex: ^NS.Object) { msgSend(nil, self, "setVisibleFunctionTable:atBufferIndex:", visibleFunctionTable, bufferIndex) } @(objc_type=IntersectionFunctionTable, objc_name="setVisibleFunctionTables") -IntersectionFunctionTable_setVisibleFunctionTables :: proc(self: ^IntersectionFunctionTable, visibleFunctionTables: ^^NS.Object, range: NS.Range) { +IntersectionFunctionTable_setVisibleFunctionTables :: #force_inline proc(self: ^IntersectionFunctionTable, visibleFunctionTables: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setVisibleFunctionTables:withBufferRange:", visibleFunctionTables, range) } @@ -7048,55 +7034,55 @@ Methods: Library :: struct { using _: NS.Object } @(objc_type=Library, objc_name="device") -Library_device :: proc(self: ^Library) -> ^Library { +Library_device :: #force_inline proc(self: ^Library) -> ^Library { return msgSend(^Library, self, "device") } @(objc_type=Library, objc_name="functionNames") -Library_functionNames :: proc(self: ^Library) -> ^NS.Array { +Library_functionNames :: #force_inline proc(self: ^Library) -> ^NS.Array { return msgSend(^NS.Array, self, "functionNames") } @(objc_type=Library, objc_name="installName") -Library_installName :: proc(self: ^Library) -> ^NS.String { +Library_installName :: #force_inline proc(self: ^Library) -> ^NS.String { return msgSend(^NS.String, self, "installName") } @(objc_type=Library, objc_name="label") -Library_label :: proc(self: ^Library) -> ^NS.String { +Library_label :: #force_inline proc(self: ^Library) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=Library, objc_name="newFunctionWithDescriptor_completionHandler_") -Library_newFunctionWithDescriptor_completionHandler_ :: proc(self: ^Library, descriptor: ^FunctionDescriptor, completionHandler: rawptr) { +Library_newFunctionWithDescriptor_completionHandler_ :: #force_inline proc(self: ^Library, descriptor: ^FunctionDescriptor, completionHandler: rawptr) { msgSend(nil, self, "newFunctionWithDescriptor:completionHandler:", descriptor, completionHandler) } @(objc_type=Library, objc_name="newFunctionWithDescriptor_error_") -Library_newFunctionWithDescriptor_error_ :: proc(self: ^Library, descriptor: ^FunctionDescriptor, error: ^^NS.Error ) -> ^Library { +Library_newFunctionWithDescriptor_error_ :: #force_inline proc(self: ^Library, descriptor: ^FunctionDescriptor, error: ^^NS.Error ) -> ^Library { return msgSend(^Library, self, "newFunctionWithDescriptor:error:", descriptor, error) } @(objc_type=Library, objc_name="newFunctionWithName") -Library_newFunctionWithName :: proc(self: ^Library, functionName: ^NS.String) -> ^Library { +Library_newFunctionWithName :: #force_inline proc(self: ^Library, functionName: ^NS.String) -> ^Library { return msgSend(^Library, self, "newFunctionWithName:", functionName) } @(objc_type=Library, objc_name="newFunctionWithName_constantValues_completionHandler_") -Library_newFunctionWithName_constantValues_completionHandler_ :: proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues, completionHandler: rawptr) { +Library_newFunctionWithName_constantValues_completionHandler_ :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues, completionHandler: rawptr) { msgSend(nil, self, "newFunctionWithName:constantValues:completionHandler:", name, constantValues, completionHandler) } @(objc_type=Library, objc_name="newFunctionWithName_constantValues_error_") -Library_newFunctionWithName_constantValues_error_ :: proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues, error: ^^NS.Error ) -> ^Library { +Library_newFunctionWithName_constantValues_error_ :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues, error: ^^NS.Error ) -> ^Library { return msgSend(^Library, self, "newFunctionWithName:constantValues:error:", name, constantValues, error) } @(objc_type=Library, objc_name="newIntersectionFunctionWithDescriptor_completionHandler_") -Library_newIntersectionFunctionWithDescriptor_completionHandler_ :: proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor, completionHandler: rawptr) { +Library_newIntersectionFunctionWithDescriptor_completionHandler_ :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor, completionHandler: rawptr) { msgSend(nil, self, "newIntersectionFunctionWithDescriptor:completionHandler:", descriptor, completionHandler) } @(objc_type=Library, objc_name="newIntersectionFunctionWithDescriptor_error_") -Library_newIntersectionFunctionWithDescriptor_error_ :: proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor, error: ^^NS.Error ) -> ^Library { +Library_newIntersectionFunctionWithDescriptor_error_ :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor, error: ^^NS.Error ) -> ^Library { return msgSend(^Library, self, "newIntersectionFunctionWithDescriptor:error:", descriptor, error) } @(objc_type=Library, objc_name="setLabel") -Library_setLabel :: proc(self: ^Library, label: ^NS.String) { +Library_setLabel :: #force_inline proc(self: ^Library, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=Library, objc_name="type") -Library_type :: proc(self: ^Library) -> LibraryType { +Library_type :: #force_inline proc(self: ^Library) -> LibraryType { return msgSend(LibraryType, self, "type") } @@ -7119,31 +7105,31 @@ Methods: ParallelRenderCommandEncoder :: struct { using _: NS.Object } @(objc_type=ParallelRenderCommandEncoder, objc_name="renderCommandEncoder") -ParallelRenderCommandEncoder_renderCommandEncoder :: proc(self: ^ParallelRenderCommandEncoder) -> ^ParallelRenderCommandEncoder { +ParallelRenderCommandEncoder_renderCommandEncoder :: #force_inline proc(self: ^ParallelRenderCommandEncoder) -> ^ParallelRenderCommandEncoder { return msgSend(^ParallelRenderCommandEncoder, self, "renderCommandEncoder") } @(objc_type=ParallelRenderCommandEncoder, objc_name="setColorStoreAction") -ParallelRenderCommandEncoder_setColorStoreAction :: proc(self: ^ParallelRenderCommandEncoder, storeAction: StoreAction, colorAttachmentIndex: ^NS.Object) { +ParallelRenderCommandEncoder_setColorStoreAction :: #force_inline proc(self: ^ParallelRenderCommandEncoder, storeAction: StoreAction, colorAttachmentIndex: ^NS.Object) { msgSend(nil, self, "setColorStoreAction:atIndex:", storeAction, colorAttachmentIndex) } @(objc_type=ParallelRenderCommandEncoder, objc_name="setColorStoreActionOptions") -ParallelRenderCommandEncoder_setColorStoreActionOptions :: proc(self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions, colorAttachmentIndex: ^NS.Object) { +ParallelRenderCommandEncoder_setColorStoreActionOptions :: #force_inline proc(self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions, colorAttachmentIndex: ^NS.Object) { msgSend(nil, self, "setColorStoreActionOptions:atIndex:", storeActionOptions, colorAttachmentIndex) } @(objc_type=ParallelRenderCommandEncoder, objc_name="setDepthStoreAction") -ParallelRenderCommandEncoder_setDepthStoreAction :: proc(self: ^ParallelRenderCommandEncoder, storeAction: StoreAction) { +ParallelRenderCommandEncoder_setDepthStoreAction :: #force_inline proc(self: ^ParallelRenderCommandEncoder, storeAction: StoreAction) { msgSend(nil, self, "setDepthStoreAction:", storeAction) } @(objc_type=ParallelRenderCommandEncoder, objc_name="setDepthStoreActionOptions") -ParallelRenderCommandEncoder_setDepthStoreActionOptions :: proc(self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions) { +ParallelRenderCommandEncoder_setDepthStoreActionOptions :: #force_inline proc(self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions) { msgSend(nil, self, "setDepthStoreActionOptions:", storeActionOptions) } @(objc_type=ParallelRenderCommandEncoder, objc_name="setStencilStoreAction") -ParallelRenderCommandEncoder_setStencilStoreAction :: proc(self: ^ParallelRenderCommandEncoder, storeAction: StoreAction) { +ParallelRenderCommandEncoder_setStencilStoreAction :: #force_inline proc(self: ^ParallelRenderCommandEncoder, storeAction: StoreAction) { msgSend(nil, self, "setStencilStoreAction:", storeAction) } @(objc_type=ParallelRenderCommandEncoder, objc_name="setStencilStoreActionOptions") -ParallelRenderCommandEncoder_setStencilStoreActionOptions :: proc(self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions) { +ParallelRenderCommandEncoder_setStencilStoreActionOptions :: #force_inline proc(self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions) { msgSend(nil, self, "setStencilStoreActionOptions:", storeActionOptions) } @@ -7169,43 +7155,43 @@ Methods: RasterizationRateMap :: struct { using _: NS.Object } @(objc_type=RasterizationRateMap, objc_name="copyParameterDataToBuffer") -RasterizationRateMap_copyParameterDataToBuffer :: proc(self: ^RasterizationRateMap, buffer: ^NS.Object, offset: ^NS.Object) { +RasterizationRateMap_copyParameterDataToBuffer :: #force_inline proc(self: ^RasterizationRateMap, buffer: ^NS.Object, offset: ^NS.Object) { msgSend(nil, self, "copyParameterDataToBuffer:offset:", buffer, offset) } @(objc_type=RasterizationRateMap, objc_name="device") -RasterizationRateMap_device :: proc(self: ^RasterizationRateMap) -> ^RasterizationRateMap { +RasterizationRateMap_device :: #force_inline proc(self: ^RasterizationRateMap) -> ^RasterizationRateMap { return msgSend(^RasterizationRateMap, self, "device") } @(objc_type=RasterizationRateMap, objc_name="label") -RasterizationRateMap_label :: proc(self: ^RasterizationRateMap) -> ^NS.String { +RasterizationRateMap_label :: #force_inline proc(self: ^RasterizationRateMap) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=RasterizationRateMap, objc_name="layerCount") -RasterizationRateMap_layerCount :: proc(self: ^RasterizationRateMap) -> NS.Integer { +RasterizationRateMap_layerCount :: #force_inline proc(self: ^RasterizationRateMap) -> NS.Integer { return msgSend(NS.Integer, self, "layerCount") } @(objc_type=RasterizationRateMap, objc_name="mapPhysicalToScreenCoordinates") -RasterizationRateMap_mapPhysicalToScreenCoordinates :: proc(self: ^RasterizationRateMap, physicalCoordinates: Coordinate2D, layerIndex: ^NS.Object) -> Coordinate2D { +RasterizationRateMap_mapPhysicalToScreenCoordinates :: #force_inline proc(self: ^RasterizationRateMap, physicalCoordinates: Coordinate2D, layerIndex: ^NS.Object) -> Coordinate2D { return msgSend(Coordinate2D, self, "mapPhysicalToScreenCoordinates:forLayer:", physicalCoordinates, layerIndex) } @(objc_type=RasterizationRateMap, objc_name="mapScreenToPhysicalCoordinates") -RasterizationRateMap_mapScreenToPhysicalCoordinates :: proc(self: ^RasterizationRateMap, screenCoordinates: Coordinate2D, layerIndex: ^NS.Object) -> Coordinate2D { +RasterizationRateMap_mapScreenToPhysicalCoordinates :: #force_inline proc(self: ^RasterizationRateMap, screenCoordinates: Coordinate2D, layerIndex: ^NS.Object) -> Coordinate2D { return msgSend(Coordinate2D, self, "mapScreenToPhysicalCoordinates:forLayer:", screenCoordinates, layerIndex) } @(objc_type=RasterizationRateMap, objc_name="parameterBufferSizeAndAlign") -RasterizationRateMap_parameterBufferSizeAndAlign :: proc(self: ^RasterizationRateMap) -> SizeAndAlign { +RasterizationRateMap_parameterBufferSizeAndAlign :: #force_inline proc(self: ^RasterizationRateMap) -> SizeAndAlign { return msgSend(SizeAndAlign, self, "parameterBufferSizeAndAlign") } @(objc_type=RasterizationRateMap, objc_name="physicalGranularity") -RasterizationRateMap_physicalGranularity :: proc(self: ^RasterizationRateMap) -> Size { +RasterizationRateMap_physicalGranularity :: #force_inline proc(self: ^RasterizationRateMap) -> Size { return msgSend(Size, self, "physicalGranularity") } @(objc_type=RasterizationRateMap, objc_name="physicalSizeForLayer") -RasterizationRateMap_physicalSizeForLayer :: proc(self: ^RasterizationRateMap, layerIndex: ^NS.Object) -> Size { +RasterizationRateMap_physicalSizeForLayer :: #force_inline proc(self: ^RasterizationRateMap, layerIndex: ^NS.Object) -> Size { return msgSend(Size, self, "physicalSizeForLayer:", layerIndex) } @(objc_type=RasterizationRateMap, objc_name="screenSize") -RasterizationRateMap_screenSize :: proc(self: ^RasterizationRateMap) -> Size { +RasterizationRateMap_screenSize :: #force_inline proc(self: ^RasterizationRateMap) -> Size { return msgSend(Size, self, "screenSize") } @@ -7307,347 +7293,347 @@ Methods: RenderCommandEncoder :: struct { using _: NS.Object } @(objc_type=RenderCommandEncoder, objc_name="dispatchThreadsPerTile") -RenderCommandEncoder_dispatchThreadsPerTile :: proc(self: ^RenderCommandEncoder, threadsPerTile: Size) { +RenderCommandEncoder_dispatchThreadsPerTile :: #force_inline proc(self: ^RenderCommandEncoder, threadsPerTile: Size) { msgSend(nil, self, "dispatchThreadsPerTile:", threadsPerTile) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexedPatches_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_indirectBuffer_indirectBufferOffset_") -RenderCommandEncoder_drawIndexedPatches_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_indirectBuffer_indirectBufferOffset_ :: proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, controlPointIndexBuffer: ^NS.Object, controlPointIndexBufferOffset: ^NS.Object, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { +RenderCommandEncoder_drawIndexedPatches_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, controlPointIndexBuffer: ^NS.Object, controlPointIndexBufferOffset: ^NS.Object, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { msgSend(nil, self, "drawIndexedPatches:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:indirectBuffer:indirectBufferOffset:", numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, indirectBuffer, indirectBufferOffset) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_") -RenderCommandEncoder_drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_ :: proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, controlPointIndexBuffer: ^NS.Object, controlPointIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) { +RenderCommandEncoder_drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, controlPointIndexBuffer: ^NS.Object, controlPointIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) { msgSend(nil, self, "drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, instanceCount, baseInstance) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_") -RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object) { +RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object) { msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_") -RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, instanceCount: ^NS.Object) { +RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, instanceCount: ^NS.Object) { msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_") -RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseVertex: ^NS.Object, baseInstance: ^NS.Object) { +RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseVertex: ^NS.Object, baseInstance: ^NS.Object) { msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount, baseVertex, baseInstance) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexType_indexBuffer_indexBufferOffset_indirectBuffer_indirectBufferOffset_") -RenderCommandEncoder_drawIndexedPrimitives_indexType_indexBuffer_indexBufferOffset_indirectBuffer_indirectBufferOffset_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { +RenderCommandEncoder_drawIndexedPrimitives_indexType_indexBuffer_indexBufferOffset_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { msgSend(nil, self, "drawIndexedPrimitives:indexType:indexBuffer:indexBufferOffset:indirectBuffer:indirectBufferOffset:", primitiveType, indexType, indexBuffer, indexBufferOffset, indirectBuffer, indirectBufferOffset) } @(objc_type=RenderCommandEncoder, objc_name="drawPatches_patchIndexBuffer_patchIndexBufferOffset_indirectBuffer_indirectBufferOffset_") -RenderCommandEncoder_drawPatches_patchIndexBuffer_patchIndexBufferOffset_indirectBuffer_indirectBufferOffset_ :: proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { +RenderCommandEncoder_drawPatches_patchIndexBuffer_patchIndexBufferOffset_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { msgSend(nil, self, "drawPatches:patchIndexBuffer:patchIndexBufferOffset:indirectBuffer:indirectBufferOffset:", numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, indirectBuffer, indirectBufferOffset) } @(objc_type=RenderCommandEncoder, objc_name="drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_") -RenderCommandEncoder_drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_ :: proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) { +RenderCommandEncoder_drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) { msgSend(nil, self, "drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance) } @(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_indirectBuffer_indirectBufferOffset_") -RenderCommandEncoder_drawPrimitives_indirectBuffer_indirectBufferOffset_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { +RenderCommandEncoder_drawPrimitives_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { msgSend(nil, self, "drawPrimitives:indirectBuffer:indirectBufferOffset:", primitiveType, indirectBuffer, indirectBufferOffset) } @(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_vertexStart_vertexCount_") -RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object) { +RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object) { msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:", primitiveType, vertexStart, vertexCount) } @(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_vertexStart_vertexCount_instanceCount_") -RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_instanceCount_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object, instanceCount: ^NS.Object) { +RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_instanceCount_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object, instanceCount: ^NS.Object) { msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:instanceCount:", primitiveType, vertexStart, vertexCount, instanceCount) } @(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_") -RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) { +RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) { msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:", primitiveType, vertexStart, vertexCount, instanceCount, baseInstance) } @(objc_type=RenderCommandEncoder, objc_name="executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_") -RenderCommandEncoder_executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_ :: proc(self: ^RenderCommandEncoder, indirectCommandbuffer: ^NS.Object, indirectRangeBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { +RenderCommandEncoder_executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, indirectCommandbuffer: ^NS.Object, indirectRangeBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { msgSend(nil, self, "executeCommandsInBuffer:indirectBuffer:indirectBufferOffset:", indirectCommandbuffer, indirectRangeBuffer, indirectBufferOffset) } @(objc_type=RenderCommandEncoder, objc_name="executeCommandsInBuffer_withRange_") -RenderCommandEncoder_executeCommandsInBuffer_withRange_ :: proc(self: ^RenderCommandEncoder, indirectCommandBuffer: ^NS.Object, executionRange: NS.Range) { +RenderCommandEncoder_executeCommandsInBuffer_withRange_ :: #force_inline proc(self: ^RenderCommandEncoder, indirectCommandBuffer: ^NS.Object, executionRange: NS.Range) { msgSend(nil, self, "executeCommandsInBuffer:withRange:", indirectCommandBuffer, executionRange) } @(objc_type=RenderCommandEncoder, objc_name="memoryBarrierWithResources") -RenderCommandEncoder_memoryBarrierWithResources :: proc(self: ^RenderCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, after: RenderStages, before: RenderStages) { +RenderCommandEncoder_memoryBarrierWithResources :: #force_inline proc(self: ^RenderCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, after: RenderStages, before: RenderStages) { msgSend(nil, self, "memoryBarrierWithResources:count:afterStages:beforeStages:", resources, count, after, before) } @(objc_type=RenderCommandEncoder, objc_name="memoryBarrierWithScope") -RenderCommandEncoder_memoryBarrierWithScope :: proc(self: ^RenderCommandEncoder, scope: BarrierScope, after: RenderStages, before: RenderStages) { +RenderCommandEncoder_memoryBarrierWithScope :: #force_inline proc(self: ^RenderCommandEncoder, scope: BarrierScope, after: RenderStages, before: RenderStages) { msgSend(nil, self, "memoryBarrierWithScope:afterStages:beforeStages:", scope, after, before) } @(objc_type=RenderCommandEncoder, objc_name="sampleCountersInBuffer") -RenderCommandEncoder_sampleCountersInBuffer :: proc(self: ^RenderCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) { +RenderCommandEncoder_sampleCountersInBuffer :: #force_inline proc(self: ^RenderCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) { msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier) } @(objc_type=RenderCommandEncoder, objc_name="setBlendColorRed") -RenderCommandEncoder_setBlendColorRed :: proc(self: ^RenderCommandEncoder, red: f32, green: f32, blue: f32, alpha: f32) { +RenderCommandEncoder_setBlendColorRed :: #force_inline proc(self: ^RenderCommandEncoder, red: f32, green: f32, blue: f32, alpha: f32) { msgSend(nil, self, "setBlendColorRed:green:blue:alpha:", red, green, blue, alpha) } @(objc_type=RenderCommandEncoder, objc_name="setColorStoreAction") -RenderCommandEncoder_setColorStoreAction :: proc(self: ^RenderCommandEncoder, storeAction: StoreAction, colorAttachmentIndex: ^NS.Object) { +RenderCommandEncoder_setColorStoreAction :: #force_inline proc(self: ^RenderCommandEncoder, storeAction: StoreAction, colorAttachmentIndex: ^NS.Object) { msgSend(nil, self, "setColorStoreAction:atIndex:", storeAction, colorAttachmentIndex) } @(objc_type=RenderCommandEncoder, objc_name="setColorStoreActionOptions") -RenderCommandEncoder_setColorStoreActionOptions :: proc(self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions, colorAttachmentIndex: ^NS.Object) { +RenderCommandEncoder_setColorStoreActionOptions :: #force_inline proc(self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions, colorAttachmentIndex: ^NS.Object) { msgSend(nil, self, "setColorStoreActionOptions:atIndex:", storeActionOptions, colorAttachmentIndex) } @(objc_type=RenderCommandEncoder, objc_name="setCullMode") -RenderCommandEncoder_setCullMode :: proc(self: ^RenderCommandEncoder, cullMode: CullMode) { +RenderCommandEncoder_setCullMode :: #force_inline proc(self: ^RenderCommandEncoder, cullMode: CullMode) { msgSend(nil, self, "setCullMode:", cullMode) } @(objc_type=RenderCommandEncoder, objc_name="setDepthBias") -RenderCommandEncoder_setDepthBias :: proc(self: ^RenderCommandEncoder, depthBias: f32, slopeScale: f32, clamp: f32) { +RenderCommandEncoder_setDepthBias :: #force_inline proc(self: ^RenderCommandEncoder, depthBias: f32, slopeScale: f32, clamp: f32) { msgSend(nil, self, "setDepthBias:slopeScale:clamp:", depthBias, slopeScale, clamp) } @(objc_type=RenderCommandEncoder, objc_name="setDepthClipMode") -RenderCommandEncoder_setDepthClipMode :: proc(self: ^RenderCommandEncoder, depthClipMode: DepthClipMode) { +RenderCommandEncoder_setDepthClipMode :: #force_inline proc(self: ^RenderCommandEncoder, depthClipMode: DepthClipMode) { msgSend(nil, self, "setDepthClipMode:", depthClipMode) } @(objc_type=RenderCommandEncoder, objc_name="setDepthStencilState") -RenderCommandEncoder_setDepthStencilState :: proc(self: ^RenderCommandEncoder, depthStencilState: ^NS.Object) { +RenderCommandEncoder_setDepthStencilState :: #force_inline proc(self: ^RenderCommandEncoder, depthStencilState: ^NS.Object) { msgSend(nil, self, "setDepthStencilState:", depthStencilState) } @(objc_type=RenderCommandEncoder, objc_name="setDepthStoreAction") -RenderCommandEncoder_setDepthStoreAction :: proc(self: ^RenderCommandEncoder, storeAction: StoreAction) { +RenderCommandEncoder_setDepthStoreAction :: #force_inline proc(self: ^RenderCommandEncoder, storeAction: StoreAction) { msgSend(nil, self, "setDepthStoreAction:", storeAction) } @(objc_type=RenderCommandEncoder, objc_name="setDepthStoreActionOptions") -RenderCommandEncoder_setDepthStoreActionOptions :: proc(self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions) { +RenderCommandEncoder_setDepthStoreActionOptions :: #force_inline proc(self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions) { msgSend(nil, self, "setDepthStoreActionOptions:", storeActionOptions) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentBuffer") -RenderCommandEncoder_setFragmentBuffer :: proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setFragmentBuffer :: #force_inline proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setFragmentBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentBufferOffset") -RenderCommandEncoder_setFragmentBufferOffset :: proc(self: ^RenderCommandEncoder, offset: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setFragmentBufferOffset :: #force_inline proc(self: ^RenderCommandEncoder, offset: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setFragmentBufferOffset:atIndex:", offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentBuffers") -RenderCommandEncoder_setFragmentBuffers :: proc(self: ^RenderCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { +RenderCommandEncoder_setFragmentBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { msgSend(nil, self, "setFragmentBuffers:offsets:withRange:", buffers, offsets, range) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentBytes") -RenderCommandEncoder_setFragmentBytes :: proc(self: ^RenderCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setFragmentBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setFragmentBytes:length:atIndex:", bytes, length, index) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerState_atIndex_") -RenderCommandEncoder_setFragmentSamplerState_atIndex_ :: proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setFragmentSamplerState_atIndex_ :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setFragmentSamplerState:atIndex:", sampler, index) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerState_lodMinClamp_lodMaxClamp_atIndex_") -RenderCommandEncoder_setFragmentSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) { +RenderCommandEncoder_setFragmentSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) { msgSend(nil, self, "setFragmentSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStates_lodMinClamps_lodMaxClamps_withRange_") -RenderCommandEncoder_setFragmentSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { +RenderCommandEncoder_setFragmentSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: #force_inline proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { msgSend(nil, self, "setFragmentSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStates_withRange_") -RenderCommandEncoder_setFragmentSamplerStates_withRange_ :: proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, range: NS.Range) { +RenderCommandEncoder_setFragmentSamplerStates_withRange_ :: #force_inline proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setFragmentSamplerStates:withRange:", samplers, range) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentTexture") -RenderCommandEncoder_setFragmentTexture :: proc(self: ^RenderCommandEncoder, texture: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setFragmentTexture :: #force_inline proc(self: ^RenderCommandEncoder, texture: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setFragmentTexture:atIndex:", texture, index) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentTextures") -RenderCommandEncoder_setFragmentTextures :: proc(self: ^RenderCommandEncoder, textures: ^^NS.Object, range: NS.Range) { +RenderCommandEncoder_setFragmentTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setFragmentTextures:withRange:", textures, range) } @(objc_type=RenderCommandEncoder, objc_name="setFrontFacingWinding") -RenderCommandEncoder_setFrontFacingWinding :: proc(self: ^RenderCommandEncoder, frontFacingWinding: Winding) { +RenderCommandEncoder_setFrontFacingWinding :: #force_inline proc(self: ^RenderCommandEncoder, frontFacingWinding: Winding) { msgSend(nil, self, "setFrontFacingWinding:", frontFacingWinding) } @(objc_type=RenderCommandEncoder, objc_name="setRenderPipelineState") -RenderCommandEncoder_setRenderPipelineState :: proc(self: ^RenderCommandEncoder, pipelineState: ^NS.Object) { +RenderCommandEncoder_setRenderPipelineState :: #force_inline proc(self: ^RenderCommandEncoder, pipelineState: ^NS.Object) { msgSend(nil, self, "setRenderPipelineState:", pipelineState) } @(objc_type=RenderCommandEncoder, objc_name="setScissorRect") -RenderCommandEncoder_setScissorRect :: proc(self: ^RenderCommandEncoder, rect: ScissorRect) { +RenderCommandEncoder_setScissorRect :: #force_inline proc(self: ^RenderCommandEncoder, rect: ScissorRect) { msgSend(nil, self, "setScissorRect:", rect) } @(objc_type=RenderCommandEncoder, objc_name="setScissorRects") -RenderCommandEncoder_setScissorRects :: proc(self: ^RenderCommandEncoder, scissorRects: ^ScissorRect, count: ^NS.Object) { +RenderCommandEncoder_setScissorRects :: #force_inline proc(self: ^RenderCommandEncoder, scissorRects: ^ScissorRect, count: ^NS.Object) { msgSend(nil, self, "setScissorRects:count:", scissorRects, count) } @(objc_type=RenderCommandEncoder, objc_name="setStencilFrontReferenceValue") -RenderCommandEncoder_setStencilFrontReferenceValue :: proc(self: ^RenderCommandEncoder, frontReferenceValue: u32, backReferenceValue: u32) { +RenderCommandEncoder_setStencilFrontReferenceValue :: #force_inline proc(self: ^RenderCommandEncoder, frontReferenceValue: u32, backReferenceValue: u32) { msgSend(nil, self, "setStencilFrontReferenceValue:backReferenceValue:", frontReferenceValue, backReferenceValue) } @(objc_type=RenderCommandEncoder, objc_name="setStencilReferenceValue") -RenderCommandEncoder_setStencilReferenceValue :: proc(self: ^RenderCommandEncoder, referenceValue: u32) { +RenderCommandEncoder_setStencilReferenceValue :: #force_inline proc(self: ^RenderCommandEncoder, referenceValue: u32) { msgSend(nil, self, "setStencilReferenceValue:", referenceValue) } @(objc_type=RenderCommandEncoder, objc_name="setStencilStoreAction") -RenderCommandEncoder_setStencilStoreAction :: proc(self: ^RenderCommandEncoder, storeAction: StoreAction) { +RenderCommandEncoder_setStencilStoreAction :: #force_inline proc(self: ^RenderCommandEncoder, storeAction: StoreAction) { msgSend(nil, self, "setStencilStoreAction:", storeAction) } @(objc_type=RenderCommandEncoder, objc_name="setStencilStoreActionOptions") -RenderCommandEncoder_setStencilStoreActionOptions :: proc(self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions) { +RenderCommandEncoder_setStencilStoreActionOptions :: #force_inline proc(self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions) { msgSend(nil, self, "setStencilStoreActionOptions:", storeActionOptions) } @(objc_type=RenderCommandEncoder, objc_name="setTessellationFactorBuffer") -RenderCommandEncoder_setTessellationFactorBuffer :: proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, instanceStride: ^NS.Object) { +RenderCommandEncoder_setTessellationFactorBuffer :: #force_inline proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, instanceStride: ^NS.Object) { msgSend(nil, self, "setTessellationFactorBuffer:offset:instanceStride:", buffer, offset, instanceStride) } @(objc_type=RenderCommandEncoder, objc_name="setTessellationFactorScale") -RenderCommandEncoder_setTessellationFactorScale :: proc(self: ^RenderCommandEncoder, scale: f32) { +RenderCommandEncoder_setTessellationFactorScale :: #force_inline proc(self: ^RenderCommandEncoder, scale: f32) { msgSend(nil, self, "setTessellationFactorScale:", scale) } @(objc_type=RenderCommandEncoder, objc_name="setThreadgroupMemoryLength") -RenderCommandEncoder_setThreadgroupMemoryLength :: proc(self: ^RenderCommandEncoder, length: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setThreadgroupMemoryLength :: #force_inline proc(self: ^RenderCommandEncoder, length: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setThreadgroupMemoryLength:offset:atIndex:", length, offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setTileBuffer") -RenderCommandEncoder_setTileBuffer :: proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setTileBuffer :: #force_inline proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setTileBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setTileBufferOffset") -RenderCommandEncoder_setTileBufferOffset :: proc(self: ^RenderCommandEncoder, offset: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setTileBufferOffset :: #force_inline proc(self: ^RenderCommandEncoder, offset: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setTileBufferOffset:atIndex:", offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setTileBuffers") -RenderCommandEncoder_setTileBuffers :: proc(self: ^RenderCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { +RenderCommandEncoder_setTileBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { msgSend(nil, self, "setTileBuffers:offsets:withRange:", buffers, offsets, range) } @(objc_type=RenderCommandEncoder, objc_name="setTileBytes") -RenderCommandEncoder_setTileBytes :: proc(self: ^RenderCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setTileBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setTileBytes:length:atIndex:", bytes, length, index) } @(objc_type=RenderCommandEncoder, objc_name="setTileSamplerState_atIndex_") -RenderCommandEncoder_setTileSamplerState_atIndex_ :: proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setTileSamplerState_atIndex_ :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setTileSamplerState:atIndex:", sampler, index) } @(objc_type=RenderCommandEncoder, objc_name="setTileSamplerState_lodMinClamp_lodMaxClamp_atIndex_") -RenderCommandEncoder_setTileSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) { +RenderCommandEncoder_setTileSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) { msgSend(nil, self, "setTileSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } @(objc_type=RenderCommandEncoder, objc_name="setTileSamplerStates_lodMinClamps_lodMaxClamps_withRange_") -RenderCommandEncoder_setTileSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { +RenderCommandEncoder_setTileSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: #force_inline proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { msgSend(nil, self, "setTileSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range) } @(objc_type=RenderCommandEncoder, objc_name="setTileSamplerStates_withRange_") -RenderCommandEncoder_setTileSamplerStates_withRange_ :: proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, range: NS.Range) { +RenderCommandEncoder_setTileSamplerStates_withRange_ :: #force_inline proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setTileSamplerStates:withRange:", samplers, range) } @(objc_type=RenderCommandEncoder, objc_name="setTileTexture") -RenderCommandEncoder_setTileTexture :: proc(self: ^RenderCommandEncoder, texture: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setTileTexture :: #force_inline proc(self: ^RenderCommandEncoder, texture: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setTileTexture:atIndex:", texture, index) } @(objc_type=RenderCommandEncoder, objc_name="setTileTextures") -RenderCommandEncoder_setTileTextures :: proc(self: ^RenderCommandEncoder, textures: ^^NS.Object, range: NS.Range) { +RenderCommandEncoder_setTileTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setTileTextures:withRange:", textures, range) } @(objc_type=RenderCommandEncoder, objc_name="setTriangleFillMode") -RenderCommandEncoder_setTriangleFillMode :: proc(self: ^RenderCommandEncoder, fillMode: TriangleFillMode) { +RenderCommandEncoder_setTriangleFillMode :: #force_inline proc(self: ^RenderCommandEncoder, fillMode: TriangleFillMode) { msgSend(nil, self, "setTriangleFillMode:", fillMode) } @(objc_type=RenderCommandEncoder, objc_name="setVertexAmplificationCount") -RenderCommandEncoder_setVertexAmplificationCount :: proc(self: ^RenderCommandEncoder, count: ^NS.Object, viewMappings: ^VertexAmplificationViewMapping) { +RenderCommandEncoder_setVertexAmplificationCount :: #force_inline proc(self: ^RenderCommandEncoder, count: ^NS.Object, viewMappings: ^VertexAmplificationViewMapping) { msgSend(nil, self, "setVertexAmplificationCount:viewMappings:", count, viewMappings) } @(objc_type=RenderCommandEncoder, objc_name="setVertexBuffer") -RenderCommandEncoder_setVertexBuffer :: proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setVertexBuffer :: #force_inline proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setVertexBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setVertexBufferOffset") -RenderCommandEncoder_setVertexBufferOffset :: proc(self: ^RenderCommandEncoder, offset: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setVertexBufferOffset :: #force_inline proc(self: ^RenderCommandEncoder, offset: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setVertexBufferOffset:atIndex:", offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setVertexBuffers") -RenderCommandEncoder_setVertexBuffers :: proc(self: ^RenderCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { +RenderCommandEncoder_setVertexBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { msgSend(nil, self, "setVertexBuffers:offsets:withRange:", buffers, offsets, range) } @(objc_type=RenderCommandEncoder, objc_name="setVertexBytes") -RenderCommandEncoder_setVertexBytes :: proc(self: ^RenderCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setVertexBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setVertexBytes:length:atIndex:", bytes, length, index) } @(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerState_atIndex_") -RenderCommandEncoder_setVertexSamplerState_atIndex_ :: proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setVertexSamplerState_atIndex_ :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setVertexSamplerState:atIndex:", sampler, index) } @(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerState_lodMinClamp_lodMaxClamp_atIndex_") -RenderCommandEncoder_setVertexSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) { +RenderCommandEncoder_setVertexSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) { msgSend(nil, self, "setVertexSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } @(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerStates_lodMinClamps_lodMaxClamps_withRange_") -RenderCommandEncoder_setVertexSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { +RenderCommandEncoder_setVertexSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: #force_inline proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { msgSend(nil, self, "setVertexSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range) } @(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerStates_withRange_") -RenderCommandEncoder_setVertexSamplerStates_withRange_ :: proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, range: NS.Range) { +RenderCommandEncoder_setVertexSamplerStates_withRange_ :: #force_inline proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setVertexSamplerStates:withRange:", samplers, range) } @(objc_type=RenderCommandEncoder, objc_name="setVertexTexture") -RenderCommandEncoder_setVertexTexture :: proc(self: ^RenderCommandEncoder, texture: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setVertexTexture :: #force_inline proc(self: ^RenderCommandEncoder, texture: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setVertexTexture:atIndex:", texture, index) } @(objc_type=RenderCommandEncoder, objc_name="setVertexTextures") -RenderCommandEncoder_setVertexTextures :: proc(self: ^RenderCommandEncoder, textures: ^^NS.Object, range: NS.Range) { +RenderCommandEncoder_setVertexTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setVertexTextures:withRange:", textures, range) } @(objc_type=RenderCommandEncoder, objc_name="setViewport") -RenderCommandEncoder_setViewport :: proc(self: ^RenderCommandEncoder, viewport: Viewport) { +RenderCommandEncoder_setViewport :: #force_inline proc(self: ^RenderCommandEncoder, viewport: Viewport) { msgSend(nil, self, "setViewport:", viewport) } @(objc_type=RenderCommandEncoder, objc_name="setViewports") -RenderCommandEncoder_setViewports :: proc(self: ^RenderCommandEncoder, viewports: ^Viewport, count: ^NS.Object) { +RenderCommandEncoder_setViewports :: #force_inline proc(self: ^RenderCommandEncoder, viewports: ^Viewport, count: ^NS.Object) { msgSend(nil, self, "setViewports:count:", viewports, count) } @(objc_type=RenderCommandEncoder, objc_name="setVisibilityResultMode") -RenderCommandEncoder_setVisibilityResultMode :: proc(self: ^RenderCommandEncoder, mode: VisibilityResultMode, offset: ^NS.Object) { +RenderCommandEncoder_setVisibilityResultMode :: #force_inline proc(self: ^RenderCommandEncoder, mode: VisibilityResultMode, offset: ^NS.Object) { msgSend(nil, self, "setVisibilityResultMode:offset:", mode, offset) } @(objc_type=RenderCommandEncoder, objc_name="textureBarrier") -RenderCommandEncoder_textureBarrier :: proc(self: ^RenderCommandEncoder) { +RenderCommandEncoder_textureBarrier :: #force_inline proc(self: ^RenderCommandEncoder) { msgSend(nil, self, "textureBarrier") } @(objc_type=RenderCommandEncoder, objc_name="tileHeight") -RenderCommandEncoder_tileHeight :: proc(self: ^RenderCommandEncoder) -> NS.Integer { +RenderCommandEncoder_tileHeight :: #force_inline proc(self: ^RenderCommandEncoder) -> NS.Integer { return msgSend(NS.Integer, self, "tileHeight") } @(objc_type=RenderCommandEncoder, objc_name="tileWidth") -RenderCommandEncoder_tileWidth :: proc(self: ^RenderCommandEncoder) -> NS.Integer { +RenderCommandEncoder_tileWidth :: #force_inline proc(self: ^RenderCommandEncoder) -> NS.Integer { return msgSend(NS.Integer, self, "tileWidth") } @(objc_type=RenderCommandEncoder, objc_name="updateFence") -RenderCommandEncoder_updateFence :: proc(self: ^RenderCommandEncoder, fence: ^NS.Object, stages: RenderStages) { +RenderCommandEncoder_updateFence :: #force_inline proc(self: ^RenderCommandEncoder, fence: ^NS.Object, stages: RenderStages) { msgSend(nil, self, "updateFence:afterStages:", fence, stages) } @(objc_type=RenderCommandEncoder, objc_name="useHeap") -RenderCommandEncoder_useHeap :: proc(self: ^RenderCommandEncoder, heap: ^NS.Object) { +RenderCommandEncoder_useHeap :: #force_inline proc(self: ^RenderCommandEncoder, heap: ^NS.Object) { msgSend(nil, self, "useHeap:", heap) } @(objc_type=RenderCommandEncoder, objc_name="useHeap_stages_") -RenderCommandEncoder_useHeap_stages_ :: proc(self: ^RenderCommandEncoder, heap: ^NS.Object, stages: RenderStages) { +RenderCommandEncoder_useHeap_stages_ :: #force_inline proc(self: ^RenderCommandEncoder, heap: ^NS.Object, stages: RenderStages) { msgSend(nil, self, "useHeap:stages:", heap, stages) } @(objc_type=RenderCommandEncoder, objc_name="useHeaps") -RenderCommandEncoder_useHeaps :: proc(self: ^RenderCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object) { +RenderCommandEncoder_useHeaps :: #force_inline proc(self: ^RenderCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object) { msgSend(nil, self, "useHeaps:count:", heaps, count) } @(objc_type=RenderCommandEncoder, objc_name="useHeaps_count_stages_") -RenderCommandEncoder_useHeaps_count_stages_ :: proc(self: ^RenderCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object, stages: RenderStages) { +RenderCommandEncoder_useHeaps_count_stages_ :: #force_inline proc(self: ^RenderCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object, stages: RenderStages) { msgSend(nil, self, "useHeaps:count:stages:", heaps, count, stages) } @(objc_type=RenderCommandEncoder, objc_name="useResource") -RenderCommandEncoder_useResource :: proc(self: ^RenderCommandEncoder, resource: ^NS.Object, usage: ResourceUsage) { +RenderCommandEncoder_useResource :: #force_inline proc(self: ^RenderCommandEncoder, resource: ^NS.Object, usage: ResourceUsage) { msgSend(nil, self, "useResource:usage:", resource, usage) } @(objc_type=RenderCommandEncoder, objc_name="useResource_usage_stages_") -RenderCommandEncoder_useResource_usage_stages_ :: proc(self: ^RenderCommandEncoder, resource: ^NS.Object, usage: ResourceUsage, stages: RenderStages) { +RenderCommandEncoder_useResource_usage_stages_ :: #force_inline proc(self: ^RenderCommandEncoder, resource: ^NS.Object, usage: ResourceUsage, stages: RenderStages) { msgSend(nil, self, "useResource:usage:stages:", resource, usage, stages) } @(objc_type=RenderCommandEncoder, objc_name="useResources") -RenderCommandEncoder_useResources :: proc(self: ^RenderCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage) { +RenderCommandEncoder_useResources :: #force_inline proc(self: ^RenderCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage) { msgSend(nil, self, "useResources:count:usage:", resources, count, usage) } @(objc_type=RenderCommandEncoder, objc_name="useResources_count_usage_stages_") -RenderCommandEncoder_useResources_count_usage_stages_ :: proc(self: ^RenderCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage, stages: RenderStages) { +RenderCommandEncoder_useResources_count_usage_stages_ :: #force_inline proc(self: ^RenderCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage, stages: RenderStages) { msgSend(nil, self, "useResources:count:usage:stages:", resources, count, usage, stages) } @(objc_type=RenderCommandEncoder, objc_name="waitForFence") -RenderCommandEncoder_waitForFence :: proc(self: ^RenderCommandEncoder, fence: ^NS.Object, stages: RenderStages) { +RenderCommandEncoder_waitForFence :: #force_inline proc(self: ^RenderCommandEncoder, fence: ^NS.Object, stages: RenderStages) { msgSend(nil, self, "waitForFence:beforeStages:", fence, stages) } @@ -7670,31 +7656,31 @@ Methods: RenderPipelineState :: struct { using _: NS.Object } @(objc_type=RenderPipelineState, objc_name="device") -RenderPipelineState_device :: proc(self: ^RenderPipelineState) -> ^RenderPipelineState { +RenderPipelineState_device :: #force_inline proc(self: ^RenderPipelineState) -> ^RenderPipelineState { return msgSend(^RenderPipelineState, self, "device") } @(objc_type=RenderPipelineState, objc_name="imageblockMemoryLengthForDimensions") -RenderPipelineState_imageblockMemoryLengthForDimensions :: proc(self: ^RenderPipelineState, imageblockDimensions: Size) -> ^RenderPipelineState { +RenderPipelineState_imageblockMemoryLengthForDimensions :: #force_inline proc(self: ^RenderPipelineState, imageblockDimensions: Size) -> ^RenderPipelineState { return msgSend(^RenderPipelineState, self, "imageblockMemoryLengthForDimensions:", imageblockDimensions) } @(objc_type=RenderPipelineState, objc_name="imageblockSampleLength") -RenderPipelineState_imageblockSampleLength :: proc(self: ^RenderPipelineState) -> NS.Integer { +RenderPipelineState_imageblockSampleLength :: #force_inline proc(self: ^RenderPipelineState) -> NS.Integer { return msgSend(NS.Integer, self, "imageblockSampleLength") } @(objc_type=RenderPipelineState, objc_name="label") -RenderPipelineState_label :: proc(self: ^RenderPipelineState) -> ^NS.String { +RenderPipelineState_label :: #force_inline proc(self: ^RenderPipelineState) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=RenderPipelineState, objc_name="maxTotalThreadsPerThreadgroup") -RenderPipelineState_maxTotalThreadsPerThreadgroup :: proc(self: ^RenderPipelineState) -> NS.Integer { +RenderPipelineState_maxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^RenderPipelineState) -> NS.Integer { return msgSend(NS.Integer, self, "maxTotalThreadsPerThreadgroup") } @(objc_type=RenderPipelineState, objc_name="supportIndirectCommandBuffers") -RenderPipelineState_supportIndirectCommandBuffers :: proc(self: ^RenderPipelineState) -> BOOL { +RenderPipelineState_supportIndirectCommandBuffers :: #force_inline proc(self: ^RenderPipelineState) -> BOOL { return msgSend(BOOL, self, "supportIndirectCommandBuffers") } @(objc_type=RenderPipelineState, objc_name="threadgroupSizeMatchesTileSize") -RenderPipelineState_threadgroupSizeMatchesTileSize :: proc(self: ^RenderPipelineState) -> BOOL { +RenderPipelineState_threadgroupSizeMatchesTileSize :: #force_inline proc(self: ^RenderPipelineState) -> BOOL { return msgSend(BOOL, self, "threadgroupSizeMatchesTileSize") } @@ -7723,55 +7709,55 @@ Methods: Resource :: struct { using _: NS.Object } @(objc_type=Resource, objc_name="allocatedSize") -Resource_allocatedSize :: proc(self: ^Resource) -> NS.Integer { +Resource_allocatedSize :: #force_inline proc(self: ^Resource) -> NS.Integer { return msgSend(NS.Integer, self, "allocatedSize") } @(objc_type=Resource, objc_name="cpuCacheMode") -Resource_cpuCacheMode :: proc(self: ^Resource) -> CPUCacheMode { +Resource_cpuCacheMode :: #force_inline proc(self: ^Resource) -> CPUCacheMode { return msgSend(CPUCacheMode, self, "cpuCacheMode") } @(objc_type=Resource, objc_name="device") -Resource_device :: proc(self: ^Resource) -> ^Resource { +Resource_device :: #force_inline proc(self: ^Resource) -> ^Resource { return msgSend(^Resource, self, "device") } @(objc_type=Resource, objc_name="hazardTrackingMode") -Resource_hazardTrackingMode :: proc(self: ^Resource) -> HazardTrackingMode { +Resource_hazardTrackingMode :: #force_inline proc(self: ^Resource) -> HazardTrackingMode { return msgSend(HazardTrackingMode, self, "hazardTrackingMode") } @(objc_type=Resource, objc_name="heap") -Resource_heap :: proc(self: ^Resource) -> ^Resource { +Resource_heap :: #force_inline proc(self: ^Resource) -> ^Resource { return msgSend(^Resource, self, "heap") } @(objc_type=Resource, objc_name="heapOffset") -Resource_heapOffset :: proc(self: ^Resource) -> NS.Integer { +Resource_heapOffset :: #force_inline proc(self: ^Resource) -> NS.Integer { return msgSend(NS.Integer, self, "heapOffset") } @(objc_type=Resource, objc_name="isAliasable") -Resource_isAliasable :: proc(self: ^Resource) -> BOOL { +Resource_isAliasable :: #force_inline proc(self: ^Resource) -> BOOL { return msgSend(BOOL, self, "isAliasable") } @(objc_type=Resource, objc_name="label") -Resource_label :: proc(self: ^Resource) -> ^NS.String { +Resource_label :: #force_inline proc(self: ^Resource) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=Resource, objc_name="makeAliasable") -Resource_makeAliasable :: proc(self: ^Resource) { +Resource_makeAliasable :: #force_inline proc(self: ^Resource) { msgSend(nil, self, "makeAliasable") } @(objc_type=Resource, objc_name="resourceOptions") -Resource_resourceOptions :: proc(self: ^Resource) -> ResourceOptions { +Resource_resourceOptions :: #force_inline proc(self: ^Resource) -> ResourceOptions { return msgSend(ResourceOptions, self, "resourceOptions") } @(objc_type=Resource, objc_name="setLabel") -Resource_setLabel :: proc(self: ^Resource, label: ^NS.String) { +Resource_setLabel :: #force_inline proc(self: ^Resource, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=Resource, objc_name="setPurgeableState") -Resource_setPurgeableState :: proc(self: ^Resource, state: PurgeableState) -> PurgeableState { +Resource_setPurgeableState :: #force_inline proc(self: ^Resource, state: PurgeableState) -> PurgeableState { return msgSend(PurgeableState, self, "setPurgeableState:", state) } @(objc_type=Resource, objc_name="storageMode") -Resource_storageMode :: proc(self: ^Resource) -> StorageMode { +Resource_storageMode :: #force_inline proc(self: ^Resource) -> StorageMode { return msgSend(StorageMode, self, "storageMode") } @@ -7792,23 +7778,23 @@ Methods: ResourceStateCommandEncoder :: struct { using _: NS.Object } @(objc_type=ResourceStateCommandEncoder, objc_name="updateFence") -ResourceStateCommandEncoder_updateFence :: proc(self: ^ResourceStateCommandEncoder, fence: ^NS.Object) { +ResourceStateCommandEncoder_updateFence :: #force_inline proc(self: ^ResourceStateCommandEncoder, fence: ^NS.Object) { msgSend(nil, self, "updateFence:", fence) } @(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMapping_mode_indirectBuffer_indirectBufferOffset_") -ResourceStateCommandEncoder_updateTextureMapping_mode_indirectBuffer_indirectBufferOffset_ :: proc(self: ^ResourceStateCommandEncoder, texture: ^NS.Object, mode: SparseTextureMappingMode, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { +ResourceStateCommandEncoder_updateTextureMapping_mode_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^ResourceStateCommandEncoder, texture: ^NS.Object, mode: SparseTextureMappingMode, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { msgSend(nil, self, "updateTextureMapping:mode:indirectBuffer:indirectBufferOffset:", texture, mode, indirectBuffer, indirectBufferOffset) } @(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMapping_mode_region_mipLevel_slice_") -ResourceStateCommandEncoder_updateTextureMapping_mode_region_mipLevel_slice_ :: proc(self: ^ResourceStateCommandEncoder, texture: ^NS.Object, mode: SparseTextureMappingMode, region: Region, mipLevel: NS.Integer, slice: NS.Integer) { +ResourceStateCommandEncoder_updateTextureMapping_mode_region_mipLevel_slice_ :: #force_inline proc(self: ^ResourceStateCommandEncoder, texture: ^NS.Object, mode: SparseTextureMappingMode, region: Region, mipLevel: NS.Integer, slice: NS.Integer) { msgSend(nil, self, "updateTextureMapping:mode:region:mipLevel:slice:", texture, mode, region, mipLevel, slice) } @(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMappings") -ResourceStateCommandEncoder_updateTextureMappings :: proc(self: ^ResourceStateCommandEncoder, texture: ^NS.Object, mode: SparseTextureMappingMode, regions: ^Region, mipLevels: NS.Integer, slices: NS.Integer, numRegions: ^NS.Object) { +ResourceStateCommandEncoder_updateTextureMappings :: #force_inline proc(self: ^ResourceStateCommandEncoder, texture: ^NS.Object, mode: SparseTextureMappingMode, regions: ^Region, mipLevels: NS.Integer, slices: NS.Integer, numRegions: ^NS.Object) { msgSend(nil, self, "updateTextureMappings:mode:regions:mipLevels:slices:numRegions:", texture, mode, regions, mipLevels, slices, numRegions) } @(objc_type=ResourceStateCommandEncoder, objc_name="waitForFence") -ResourceStateCommandEncoder_waitForFence :: proc(self: ^ResourceStateCommandEncoder, fence: ^NS.Object) { +ResourceStateCommandEncoder_waitForFence :: #force_inline proc(self: ^ResourceStateCommandEncoder, fence: ^NS.Object) { msgSend(nil, self, "waitForFence:", fence) } @@ -7826,11 +7812,11 @@ Methods: SamplerState :: struct { using _: NS.Object } @(objc_type=SamplerState, objc_name="device") -SamplerState_device :: proc(self: ^SamplerState) -> ^SamplerState { +SamplerState_device :: #force_inline proc(self: ^SamplerState) -> ^SamplerState { return msgSend(^SamplerState, self, "device") } @(objc_type=SamplerState, objc_name="label") -SamplerState_label :: proc(self: ^SamplerState) -> ^NS.String { +SamplerState_label :: #force_inline proc(self: ^SamplerState) -> ^NS.String { return msgSend(^NS.String, self, "label") } @@ -7850,19 +7836,19 @@ Methods: SharedEvent :: struct { using _: NS.Object } @(objc_type=SharedEvent, objc_name="newSharedEventHandle") -SharedEvent_newSharedEventHandle :: proc(self: ^SharedEvent) -> ^SharedEventHandle { +SharedEvent_newSharedEventHandle :: #force_inline proc(self: ^SharedEvent) -> ^SharedEventHandle { return msgSend(^SharedEventHandle, self, "newSharedEventHandle") } @(objc_type=SharedEvent, objc_name="notifyListener") -SharedEvent_notifyListener :: proc(self: ^SharedEvent, listener: ^SharedEventListener, value: u64, block: SharedEventNotificationBlock) { +SharedEvent_notifyListener :: #force_inline proc(self: ^SharedEvent, listener: ^SharedEventListener, value: u64, block: SharedEventNotificationBlock) { msgSend(nil, self, "notifyListener:atValue:block:", listener, value, block) } @(objc_type=SharedEvent, objc_name="setSignaledValue") -SharedEvent_setSignaledValue :: proc(self: ^SharedEvent, signaledValue: u64) { +SharedEvent_setSignaledValue :: #force_inline proc(self: ^SharedEvent, signaledValue: u64) { msgSend(nil, self, "setSignaledValue:", signaledValue) } @(objc_type=SharedEvent, objc_name="signaledValue") -SharedEvent_signaledValue :: proc(self: ^SharedEvent) -> u64 { +SharedEvent_signaledValue :: #force_inline proc(self: ^SharedEvent) -> u64 { return msgSend(u64, self, "signaledValue") } @@ -7913,143 +7899,143 @@ Methods: Texture :: struct { using _: NS.Object } @(objc_type=Texture, objc_name="allowGPUOptimizedContents") -Texture_allowGPUOptimizedContents :: proc(self: ^Texture) -> BOOL { +Texture_allowGPUOptimizedContents :: #force_inline proc(self: ^Texture) -> BOOL { return msgSend(BOOL, self, "allowGPUOptimizedContents") } @(objc_type=Texture, objc_name="arrayLength") -Texture_arrayLength :: proc(self: ^Texture) -> NS.Integer { +Texture_arrayLength :: #force_inline proc(self: ^Texture) -> NS.Integer { return msgSend(NS.Integer, self, "arrayLength") } @(objc_type=Texture, objc_name="buffer") -Texture_buffer :: proc(self: ^Texture) -> ^Texture { +Texture_buffer :: #force_inline proc(self: ^Texture) -> ^Texture { return msgSend(^Texture, self, "buffer") } @(objc_type=Texture, objc_name="bufferBytesPerRow") -Texture_bufferBytesPerRow :: proc(self: ^Texture) -> NS.Integer { +Texture_bufferBytesPerRow :: #force_inline proc(self: ^Texture) -> NS.Integer { return msgSend(NS.Integer, self, "bufferBytesPerRow") } @(objc_type=Texture, objc_name="bufferOffset") -Texture_bufferOffset :: proc(self: ^Texture) -> NS.Integer { +Texture_bufferOffset :: #force_inline proc(self: ^Texture) -> NS.Integer { return msgSend(NS.Integer, self, "bufferOffset") } @(objc_type=Texture, objc_name="depth") -Texture_depth :: proc(self: ^Texture) -> NS.Integer { +Texture_depth :: #force_inline proc(self: ^Texture) -> NS.Integer { return msgSend(NS.Integer, self, "depth") } @(objc_type=Texture, objc_name="firstMipmapInTail") -Texture_firstMipmapInTail :: proc(self: ^Texture) -> NS.Integer { +Texture_firstMipmapInTail :: #force_inline proc(self: ^Texture) -> NS.Integer { return msgSend(NS.Integer, self, "firstMipmapInTail") } @(objc_type=Texture, objc_name="getBytes_bytesPerRow_bytesPerImage_fromRegion_mipmapLevel_slice_") -Texture_getBytes_bytesPerRow_bytesPerImage_fromRegion_mipmapLevel_slice_ :: proc(self: ^Texture, pixelBytes: rawptr, bytesPerRow: ^NS.Object, bytesPerImage: ^NS.Object, region: Region, level: ^NS.Object, slice: ^NS.Object) { +Texture_getBytes_bytesPerRow_bytesPerImage_fromRegion_mipmapLevel_slice_ :: #force_inline proc(self: ^Texture, pixelBytes: rawptr, bytesPerRow: ^NS.Object, bytesPerImage: ^NS.Object, region: Region, level: ^NS.Object, slice: ^NS.Object) { msgSend(nil, self, "getBytes:bytesPerRow:bytesPerImage:fromRegion:mipmapLevel:slice:", pixelBytes, bytesPerRow, bytesPerImage, region, level, slice) } @(objc_type=Texture, objc_name="getBytes_bytesPerRow_fromRegion_mipmapLevel_") -Texture_getBytes_bytesPerRow_fromRegion_mipmapLevel_ :: proc(self: ^Texture, pixelBytes: rawptr, bytesPerRow: ^NS.Object, region: Region, level: ^NS.Object) { +Texture_getBytes_bytesPerRow_fromRegion_mipmapLevel_ :: #force_inline proc(self: ^Texture, pixelBytes: rawptr, bytesPerRow: ^NS.Object, region: Region, level: ^NS.Object) { msgSend(nil, self, "getBytes:bytesPerRow:fromRegion:mipmapLevel:", pixelBytes, bytesPerRow, region, level) } @(objc_type=Texture, objc_name="height") -Texture_height :: proc(self: ^Texture) -> NS.Integer { +Texture_height :: #force_inline proc(self: ^Texture) -> NS.Integer { return msgSend(NS.Integer, self, "height") } @(objc_type=Texture, objc_name="iosurface") -Texture_iosurface :: proc(self: ^Texture) -> IOSurfaceRef { +Texture_iosurface :: #force_inline proc(self: ^Texture) -> IOSurfaceRef { return msgSend(IOSurfaceRef, self, "iosurface") } @(objc_type=Texture, objc_name="iosurfacePlane") -Texture_iosurfacePlane :: proc(self: ^Texture) -> NS.Integer { +Texture_iosurfacePlane :: #force_inline proc(self: ^Texture) -> NS.Integer { return msgSend(NS.Integer, self, "iosurfacePlane") } @(objc_type=Texture, objc_name="isFramebufferOnly") -Texture_isFramebufferOnly :: proc(self: ^Texture) -> BOOL { +Texture_isFramebufferOnly :: #force_inline proc(self: ^Texture) -> BOOL { return msgSend(BOOL, self, "isFramebufferOnly") } @(objc_type=Texture, objc_name="isShareable") -Texture_isShareable :: proc(self: ^Texture) -> BOOL { +Texture_isShareable :: #force_inline proc(self: ^Texture) -> BOOL { return msgSend(BOOL, self, "isShareable") } @(objc_type=Texture, objc_name="isSparse") -Texture_isSparse :: proc(self: ^Texture) -> BOOL { +Texture_isSparse :: #force_inline proc(self: ^Texture) -> BOOL { return msgSend(BOOL, self, "isSparse") } @(objc_type=Texture, objc_name="mipmapLevelCount") -Texture_mipmapLevelCount :: proc(self: ^Texture) -> NS.Integer { +Texture_mipmapLevelCount :: #force_inline proc(self: ^Texture) -> NS.Integer { return msgSend(NS.Integer, self, "mipmapLevelCount") } @(objc_type=Texture, objc_name="newRemoteTextureViewForDevice") -Texture_newRemoteTextureViewForDevice :: proc(self: ^Texture, device: ^NS.Object) -> ^Texture { +Texture_newRemoteTextureViewForDevice :: #force_inline proc(self: ^Texture, device: ^NS.Object) -> ^Texture { return msgSend(^Texture, self, "newRemoteTextureViewForDevice:", device) } @(objc_type=Texture, objc_name="newSharedTextureHandle") -Texture_newSharedTextureHandle :: proc(self: ^Texture) -> ^SharedTextureHandle { +Texture_newSharedTextureHandle :: #force_inline proc(self: ^Texture) -> ^SharedTextureHandle { return msgSend(^SharedTextureHandle, self, "newSharedTextureHandle") } @(objc_type=Texture, objc_name="newTextureViewWithPixelFormat") -Texture_newTextureViewWithPixelFormat :: proc(self: ^Texture, pixelFormat: PixelFormat) -> ^Texture { +Texture_newTextureViewWithPixelFormat :: #force_inline proc(self: ^Texture, pixelFormat: PixelFormat) -> ^Texture { return msgSend(^Texture, self, "newTextureViewWithPixelFormat:", pixelFormat) } @(objc_type=Texture, objc_name="newTextureViewWithPixelFormat_textureType_levels_slices_") -Texture_newTextureViewWithPixelFormat_textureType_levels_slices_ :: proc(self: ^Texture, pixelFormat: PixelFormat, textureType: TextureType, levelRange: NS.Range, sliceRange: NS.Range) -> ^Texture { +Texture_newTextureViewWithPixelFormat_textureType_levels_slices_ :: #force_inline proc(self: ^Texture, pixelFormat: PixelFormat, textureType: TextureType, levelRange: NS.Range, sliceRange: NS.Range) -> ^Texture { return msgSend(^Texture, self, "newTextureViewWithPixelFormat:textureType:levels:slices:", pixelFormat, textureType, levelRange, sliceRange) } @(objc_type=Texture, objc_name="newTextureViewWithPixelFormat_textureType_levels_slices_swizzle_") -Texture_newTextureViewWithPixelFormat_textureType_levels_slices_swizzle_ :: proc(self: ^Texture, pixelFormat: PixelFormat, textureType: TextureType, levelRange: NS.Range, sliceRange: NS.Range, swizzle: TextureSwizzleChannels) -> ^Texture { +Texture_newTextureViewWithPixelFormat_textureType_levels_slices_swizzle_ :: #force_inline proc(self: ^Texture, pixelFormat: PixelFormat, textureType: TextureType, levelRange: NS.Range, sliceRange: NS.Range, swizzle: TextureSwizzleChannels) -> ^Texture { return msgSend(^Texture, self, "newTextureViewWithPixelFormat:textureType:levels:slices:swizzle:", pixelFormat, textureType, levelRange, sliceRange, swizzle) } @(objc_type=Texture, objc_name="parentRelativeLevel") -Texture_parentRelativeLevel :: proc(self: ^Texture) -> NS.Integer { +Texture_parentRelativeLevel :: #force_inline proc(self: ^Texture) -> NS.Integer { return msgSend(NS.Integer, self, "parentRelativeLevel") } @(objc_type=Texture, objc_name="parentRelativeSlice") -Texture_parentRelativeSlice :: proc(self: ^Texture) -> NS.Integer { +Texture_parentRelativeSlice :: #force_inline proc(self: ^Texture) -> NS.Integer { return msgSend(NS.Integer, self, "parentRelativeSlice") } @(objc_type=Texture, objc_name="parentTexture") -Texture_parentTexture :: proc(self: ^Texture) -> ^Texture { +Texture_parentTexture :: #force_inline proc(self: ^Texture) -> ^Texture { return msgSend(^Texture, self, "parentTexture") } @(objc_type=Texture, objc_name="pixelFormat") -Texture_pixelFormat :: proc(self: ^Texture) -> PixelFormat { +Texture_pixelFormat :: #force_inline proc(self: ^Texture) -> PixelFormat { return msgSend(PixelFormat, self, "pixelFormat") } @(objc_type=Texture, objc_name="remoteStorageTexture") -Texture_remoteStorageTexture :: proc(self: ^Texture) -> ^Texture { +Texture_remoteStorageTexture :: #force_inline proc(self: ^Texture) -> ^Texture { return msgSend(^Texture, self, "remoteStorageTexture") } @(objc_type=Texture, objc_name="replaceRegion_mipmapLevel_slice_withBytes_bytesPerRow_bytesPerImage_") -Texture_replaceRegion_mipmapLevel_slice_withBytes_bytesPerRow_bytesPerImage_ :: proc(self: ^Texture, region: Region, level: ^NS.Object, slice: ^NS.Object, pixelBytes: rawptr, bytesPerRow: ^NS.Object, bytesPerImage: ^NS.Object) { +Texture_replaceRegion_mipmapLevel_slice_withBytes_bytesPerRow_bytesPerImage_ :: #force_inline proc(self: ^Texture, region: Region, level: ^NS.Object, slice: ^NS.Object, pixelBytes: rawptr, bytesPerRow: ^NS.Object, bytesPerImage: ^NS.Object) { msgSend(nil, self, "replaceRegion:mipmapLevel:slice:withBytes:bytesPerRow:bytesPerImage:", region, level, slice, pixelBytes, bytesPerRow, bytesPerImage) } @(objc_type=Texture, objc_name="replaceRegion_mipmapLevel_withBytes_bytesPerRow_") -Texture_replaceRegion_mipmapLevel_withBytes_bytesPerRow_ :: proc(self: ^Texture, region: Region, level: ^NS.Object, pixelBytes: rawptr, bytesPerRow: ^NS.Object) { +Texture_replaceRegion_mipmapLevel_withBytes_bytesPerRow_ :: #force_inline proc(self: ^Texture, region: Region, level: ^NS.Object, pixelBytes: rawptr, bytesPerRow: ^NS.Object) { msgSend(nil, self, "replaceRegion:mipmapLevel:withBytes:bytesPerRow:", region, level, pixelBytes, bytesPerRow) } @(objc_type=Texture, objc_name="rootResource") -Texture_rootResource :: proc(self: ^Texture) -> ^Texture { +Texture_rootResource :: #force_inline proc(self: ^Texture) -> ^Texture { return msgSend(^Texture, self, "rootResource") } @(objc_type=Texture, objc_name="sampleCount") -Texture_sampleCount :: proc(self: ^Texture) -> NS.Integer { +Texture_sampleCount :: #force_inline proc(self: ^Texture) -> NS.Integer { return msgSend(NS.Integer, self, "sampleCount") } @(objc_type=Texture, objc_name="swizzle") -Texture_swizzle :: proc(self: ^Texture) -> TextureSwizzleChannels { +Texture_swizzle :: #force_inline proc(self: ^Texture) -> TextureSwizzleChannels { return msgSend(TextureSwizzleChannels, self, "swizzle") } @(objc_type=Texture, objc_name="tailSizeInBytes") -Texture_tailSizeInBytes :: proc(self: ^Texture) -> NS.Integer { +Texture_tailSizeInBytes :: #force_inline proc(self: ^Texture) -> NS.Integer { return msgSend(NS.Integer, self, "tailSizeInBytes") } @(objc_type=Texture, objc_name="textureType") -Texture_textureType :: proc(self: ^Texture) -> TextureType { +Texture_textureType :: #force_inline proc(self: ^Texture) -> TextureType { return msgSend(TextureType, self, "textureType") } @(objc_type=Texture, objc_name="usage") -Texture_usage :: proc(self: ^Texture) -> TextureUsage { +Texture_usage :: #force_inline proc(self: ^Texture) -> TextureUsage { return msgSend(TextureUsage, self, "usage") } @(objc_type=Texture, objc_name="width") -Texture_width :: proc(self: ^Texture) -> NS.Integer { +Texture_width :: #force_inline proc(self: ^Texture) -> NS.Integer { return msgSend(NS.Integer, self, "width") } @@ -8067,10 +8053,10 @@ Methods: VisibleFunctionTable :: struct { using _: NS.Object } @(objc_type=VisibleFunctionTable, objc_name="setFunction") -VisibleFunctionTable_setFunction :: proc(self: ^VisibleFunctionTable, function: ^NS.Object, index: ^NS.Object) { +VisibleFunctionTable_setFunction :: #force_inline proc(self: ^VisibleFunctionTable, function: ^NS.Object, index: ^NS.Object) { msgSend(nil, self, "setFunction:atIndex:", function, index) } @(objc_type=VisibleFunctionTable, objc_name="setFunctions") -VisibleFunctionTable_setFunctions :: proc(self: ^VisibleFunctionTable, functions: ^^NS.Object, range: NS.Range) { +VisibleFunctionTable_setFunctions :: #force_inline proc(self: ^VisibleFunctionTable, functions: ^^NS.Object, range: NS.Range) { msgSend(nil, self, "setFunctions:withRange:", functions, range) } diff --git a/vendor/Metal/MetalProcedures.odin b/vendor/Metal/MetalProcedures.odin new file mode 100644 index 000000000..120396b5d --- /dev/null +++ b/vendor/Metal/MetalProcedures.odin @@ -0,0 +1,14 @@ +package objc_Metal + +import NS "core:sys/darwin/Foundation" + +@(require) +foreign import "system:Metal.framework" + +@(default_calling_convention="c", link_prefix="MTL") +foreign Metal { + CopyAllDevices :: proc() -> ^NS.Array --- + CopyAllDevicesWithObserver :: proc(observer: ^^NS.Object, handler: DeviceNotificationHandler) -> ^NS.Array --- + CreateSystemDefaultDevice :: proc() -> ^NS.Object --- + RemoveDeviceObserver :: proc(observer: ^NS.Object) --- +} \ No newline at end of file From ff5d6a994bbaf379729a56e151bb888ce12fa975 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Sat, 12 Feb 2022 17:59:40 +0000 Subject: [PATCH 16/64] Move vendor:Metal to core:sys/darwin/Metal --- {vendor => core/sys/darwin}/Metal/MetalClasses.odin | 0 {vendor => core/sys/darwin}/Metal/MetalEnums.odin | 4 ++-- {vendor => core/sys/darwin}/Metal/MetalErrors.odin | 0 {vendor => core/sys/darwin}/Metal/MetalProcedures.odin | 0 {vendor => core/sys/darwin}/Metal/MetalTypes.odin | 0 5 files changed, 2 insertions(+), 2 deletions(-) rename {vendor => core/sys/darwin}/Metal/MetalClasses.odin (100%) rename {vendor => core/sys/darwin}/Metal/MetalEnums.odin (99%) rename {vendor => core/sys/darwin}/Metal/MetalErrors.odin (100%) rename {vendor => core/sys/darwin}/Metal/MetalProcedures.odin (100%) rename {vendor => core/sys/darwin}/Metal/MetalTypes.odin (100%) diff --git a/vendor/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin similarity index 100% rename from vendor/Metal/MetalClasses.odin rename to core/sys/darwin/Metal/MetalClasses.odin diff --git a/vendor/Metal/MetalEnums.odin b/core/sys/darwin/Metal/MetalEnums.odin similarity index 99% rename from vendor/Metal/MetalEnums.odin rename to core/sys/darwin/Metal/MetalEnums.odin index a0bd7b970..0e3aec321 100644 --- a/vendor/Metal/MetalEnums.odin +++ b/core/sys/darwin/Metal/MetalEnums.odin @@ -197,7 +197,7 @@ CommandEncoderErrorState :: enum NS.Integer { CommandBufferHandler :: distinct rawptr DispatchType :: enum NS.UInteger { - Serial = 0, + Serial = 0, Concurrent = 1, } @@ -220,7 +220,7 @@ BarrierScope :: distinct bit_set[BarrierScopeFlag; NS.UInteger] CounterSampleBufferError :: enum NS.Integer { OutOfMemory = 0, - Invalid = 1, + Invalid = 1, } CompareFunction :: enum NS.UInteger { diff --git a/vendor/Metal/MetalErrors.odin b/core/sys/darwin/Metal/MetalErrors.odin similarity index 100% rename from vendor/Metal/MetalErrors.odin rename to core/sys/darwin/Metal/MetalErrors.odin diff --git a/vendor/Metal/MetalProcedures.odin b/core/sys/darwin/Metal/MetalProcedures.odin similarity index 100% rename from vendor/Metal/MetalProcedures.odin rename to core/sys/darwin/Metal/MetalProcedures.odin diff --git a/vendor/Metal/MetalTypes.odin b/core/sys/darwin/Metal/MetalTypes.odin similarity index 100% rename from vendor/Metal/MetalTypes.odin rename to core/sys/darwin/Metal/MetalTypes.odin From 5fe9aa919b97dcfac7db3b49a8e339ec45f98a6b Mon Sep 17 00:00:00 2001 From: gingerBill Date: Sat, 12 Feb 2022 21:24:28 +0000 Subject: [PATCH 17/64] Correct types in methods --- core/sys/darwin/Metal/MetalClasses.odin | 1483 ++++++++++---------- core/sys/darwin/Metal/MetalProcedures.odin | 6 +- core/sys/darwin/Metal/MetalTypes.odin | 4 + examples/objc/objc_main.odin | 8 + 4 files changed, 793 insertions(+), 708 deletions(-) create mode 100644 examples/objc/objc_main.odin diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 4f788cb55..5695cbb6f 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -37,40 +37,88 @@ AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBuffer :: #force_i return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, self, "boundingBoxBuffer") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxBufferOffset") -AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBufferOffset :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "boundingBoxBufferOffset") +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBufferOffset :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "boundingBoxBufferOffset") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxCount") -AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxCount :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "boundingBoxCount") +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxCount :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "boundingBoxCount") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxStride") -AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxStride :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "boundingBoxStride") +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxStride :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "boundingBoxStride") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_class_name="descriptor") AccelerationStructureBoundingBoxGeometryDescriptor_descriptor :: #force_inline proc() -> ^AccelerationStructureBoundingBoxGeometryDescriptor { return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, AccelerationStructureBoundingBoxGeometryDescriptor, "descriptor") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxBuffer") -AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBuffer :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBuffer: ^NS.Object) { +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBuffer :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBuffer: ^Buffer) { msgSend(nil, self, "setBoundingBoxBuffer:", boundingBoxBuffer) } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxBufferOffset") -AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBufferOffset :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBufferOffset: NS.Integer) { +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBufferOffset :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBufferOffset: NS.UInteger) { msgSend(nil, self, "setBoundingBoxBufferOffset:", boundingBoxBufferOffset) } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxCount") -AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxCount :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxCount: NS.Integer) { +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxCount :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxCount: NS.UInteger) { msgSend(nil, self, "setBoundingBoxCount:", boundingBoxCount) } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxStride") -AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxStride :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxStride: NS.Integer) { +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxStride :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxStride: NS.UInteger) { msgSend(nil, self, "setBoundingBoxStride:", boundingBoxStride) } //////////////////////////////////////////////////////////////////////////////// +/* +Class: + MotionKeyframeData +Class Methods: + alloc + data +Methods: + init + buffer + setBuffer + offset + setOffset +*/ + +@(objc_class="MTLMotionKeyframeData") +MotionKeyframeData :: struct { using _: NS.Object } + +@(objc_type=MotionKeyframeData, objc_class_name="alloc") +MotionKeyframeData_alloc :: #force_inline proc() -> ^MotionKeyframeData { + return msgSend(^MotionKeyframeData, MotionKeyframeData, "alloc") +} +@(objc_type=MotionKeyframeData, objc_class_name="data") +MotionKeyframeData_data :: #force_inline proc() -> ^MotionKeyframeData { + return msgSend(^MotionKeyframeData, MotionKeyframeData, "data") +} +@(objc_type=MotionKeyframeData, objc_class_name="init") +MotionKeyframeData_init :: #force_inline proc(self: ^MotionKeyframeData) -> ^MotionKeyframeData { + return msgSend(^MotionKeyframeData, self, "init") +} +@(objc_type=MotionKeyframeData, objc_class_name="buffer") +MotionKeyframeData_buffer :: #force_inline proc(self: ^MotionKeyframeData) -> ^Buffer { + return msgSend(^Buffer, self, "buffer") +} +@(objc_type=MotionKeyframeData, objc_class_name="setBuffer") +MotionKeyframeData_setBuffer :: #force_inline proc(self: ^MotionKeyframeData, buffer: ^Buffer) { + msgSend(nil, self, "setBuffer:", buffer) +} +@(objc_type=MotionKeyframeData, objc_class_name="offset") +MotionKeyframeData_offset :: #force_inline proc(self: ^MotionKeyframeData) -> NS.UInteger { + return msgSend(NS.UInteger, self, "offset") +} +@(objc_type=MotionKeyframeData, objc_class_name="setOffset") +MotionKeyframeData_setOffset :: #force_inline proc(self: ^MotionKeyframeData, offset: NS.UInteger) { + msgSend(nil, self, "setOffset:", offset) +} + +//////////////////////////////////////////////////////////////////////////////// + /* Class: AccelerationStructureDescriptor @@ -133,8 +181,8 @@ AccelerationStructureGeometryDescriptor_allowDuplicateIntersectionFunctionInvoca return msgSend(BOOL, self, "allowDuplicateIntersectionFunctionInvocation") } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="intersectionFunctionTableOffset") -AccelerationStructureGeometryDescriptor_intersectionFunctionTableOffset :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "intersectionFunctionTableOffset") +AccelerationStructureGeometryDescriptor_intersectionFunctionTableOffset :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "intersectionFunctionTableOffset") } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="opaque") AccelerationStructureGeometryDescriptor_opaque :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor) -> BOOL { @@ -145,7 +193,7 @@ AccelerationStructureGeometryDescriptor_setAllowDuplicateIntersectionFunctionInv msgSend(nil, self, "setAllowDuplicateIntersectionFunctionInvocation:", allowDuplicateIntersectionFunctionInvocation) } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="setIntersectionFunctionTableOffset") -AccelerationStructureGeometryDescriptor_setIntersectionFunctionTableOffset :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor, intersectionFunctionTableOffset: NS.Integer) { +AccelerationStructureGeometryDescriptor_setIntersectionFunctionTableOffset :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor, intersectionFunctionTableOffset: NS.UInteger) { msgSend(nil, self, "setIntersectionFunctionTableOffset:", intersectionFunctionTableOffset) } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="setOpaque") @@ -198,19 +246,19 @@ AccelerationStructureTriangleGeometryDescriptor_indexBuffer :: #force_inline pro return msgSend(^AccelerationStructureTriangleGeometryDescriptor, self, "indexBuffer") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="indexBufferOffset") -AccelerationStructureTriangleGeometryDescriptor_indexBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "indexBufferOffset") +AccelerationStructureTriangleGeometryDescriptor_indexBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "indexBufferOffset") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="indexType") AccelerationStructureTriangleGeometryDescriptor_indexType :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> IndexType { return msgSend(IndexType, self, "indexType") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setIndexBuffer") -AccelerationStructureTriangleGeometryDescriptor_setIndexBuffer :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexBuffer: ^NS.Object) { +AccelerationStructureTriangleGeometryDescriptor_setIndexBuffer :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexBuffer: ^Buffer) { msgSend(nil, self, "setIndexBuffer:", indexBuffer) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setIndexBufferOffset") -AccelerationStructureTriangleGeometryDescriptor_setIndexBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexBufferOffset: NS.Integer) { +AccelerationStructureTriangleGeometryDescriptor_setIndexBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexBufferOffset: NS.UInteger) { msgSend(nil, self, "setIndexBufferOffset:", indexBufferOffset) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setIndexType") @@ -218,36 +266,36 @@ AccelerationStructureTriangleGeometryDescriptor_setIndexType :: #force_inline pr msgSend(nil, self, "setIndexType:", indexType) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setTriangleCount") -AccelerationStructureTriangleGeometryDescriptor_setTriangleCount :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, triangleCount: NS.Integer) { +AccelerationStructureTriangleGeometryDescriptor_setTriangleCount :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, triangleCount: NS.UInteger) { msgSend(nil, self, "setTriangleCount:", triangleCount) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setVertexBuffer") -AccelerationStructureTriangleGeometryDescriptor_setVertexBuffer :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexBuffer: ^NS.Object) { +AccelerationStructureTriangleGeometryDescriptor_setVertexBuffer :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexBuffer: ^Buffer) { msgSend(nil, self, "setVertexBuffer:", vertexBuffer) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setVertexBufferOffset") -AccelerationStructureTriangleGeometryDescriptor_setVertexBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexBufferOffset: NS.Integer) { +AccelerationStructureTriangleGeometryDescriptor_setVertexBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexBufferOffset: NS.UInteger) { msgSend(nil, self, "setVertexBufferOffset:", vertexBufferOffset) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setVertexStride") -AccelerationStructureTriangleGeometryDescriptor_setVertexStride :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexStride: NS.Integer) { +AccelerationStructureTriangleGeometryDescriptor_setVertexStride :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexStride: NS.UInteger) { msgSend(nil, self, "setVertexStride:", vertexStride) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="triangleCount") -AccelerationStructureTriangleGeometryDescriptor_triangleCount :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "triangleCount") +AccelerationStructureTriangleGeometryDescriptor_triangleCount :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "triangleCount") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="vertexBuffer") AccelerationStructureTriangleGeometryDescriptor_vertexBuffer :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^AccelerationStructureTriangleGeometryDescriptor { return msgSend(^AccelerationStructureTriangleGeometryDescriptor, self, "vertexBuffer") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="vertexBufferOffset") -AccelerationStructureTriangleGeometryDescriptor_vertexBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "vertexBufferOffset") +AccelerationStructureTriangleGeometryDescriptor_vertexBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "vertexBufferOffset") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="vertexStride") -AccelerationStructureTriangleGeometryDescriptor_vertexStride :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "vertexStride") +AccelerationStructureTriangleGeometryDescriptor_vertexStride :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "vertexStride") } //////////////////////////////////////////////////////////////////////////////// @@ -292,16 +340,16 @@ Argument_access :: #force_inline proc(self: ^Argument) -> ArgumentAccess { return msgSend(ArgumentAccess, self, "access") } @(objc_type=Argument, objc_name="arrayLength") -Argument_arrayLength :: #force_inline proc(self: ^Argument) -> NS.Integer { - return msgSend(NS.Integer, self, "arrayLength") +Argument_arrayLength :: #force_inline proc(self: ^Argument) -> NS.UInteger { + return msgSend(NS.UInteger, self, "arrayLength") } @(objc_type=Argument, objc_name="bufferAlignment") -Argument_bufferAlignment :: #force_inline proc(self: ^Argument) -> NS.Integer { - return msgSend(NS.Integer, self, "bufferAlignment") +Argument_bufferAlignment :: #force_inline proc(self: ^Argument) -> NS.UInteger { + return msgSend(NS.UInteger, self, "bufferAlignment") } @(objc_type=Argument, objc_name="bufferDataSize") -Argument_bufferDataSize :: #force_inline proc(self: ^Argument) -> NS.Integer { - return msgSend(NS.Integer, self, "bufferDataSize") +Argument_bufferDataSize :: #force_inline proc(self: ^Argument) -> NS.UInteger { + return msgSend(NS.UInteger, self, "bufferDataSize") } @(objc_type=Argument, objc_name="bufferDataType") Argument_bufferDataType :: #force_inline proc(self: ^Argument) -> DataType { @@ -316,8 +364,8 @@ Argument_bufferStructType :: #force_inline proc(self: ^Argument) -> ^StructType return msgSend(^StructType, self, "bufferStructType") } @(objc_type=Argument, objc_name="index") -Argument_index :: #force_inline proc(self: ^Argument) -> NS.Integer { - return msgSend(NS.Integer, self, "index") +Argument_index :: #force_inline proc(self: ^Argument) -> NS.UInteger { + return msgSend(NS.UInteger, self, "index") } @(objc_type=Argument, objc_name="isActive") Argument_isActive :: #force_inline proc(self: ^Argument) -> BOOL { @@ -340,12 +388,12 @@ Argument_textureType :: #force_inline proc(self: ^Argument) -> TextureType { return msgSend(TextureType, self, "textureType") } @(objc_type=Argument, objc_name="threadgroupMemoryAlignment") -Argument_threadgroupMemoryAlignment :: #force_inline proc(self: ^Argument) -> NS.Integer { - return msgSend(NS.Integer, self, "threadgroupMemoryAlignment") +Argument_threadgroupMemoryAlignment :: #force_inline proc(self: ^Argument) -> NS.UInteger { + return msgSend(NS.UInteger, self, "threadgroupMemoryAlignment") } @(objc_type=Argument, objc_name="threadgroupMemoryDataSize") -Argument_threadgroupMemoryDataSize :: #force_inline proc(self: ^Argument) -> NS.Integer { - return msgSend(NS.Integer, self, "threadgroupMemoryDataSize") +Argument_threadgroupMemoryDataSize :: #force_inline proc(self: ^Argument) -> NS.UInteger { + return msgSend(NS.UInteger, self, "threadgroupMemoryDataSize") } @(objc_type=Argument, objc_name="type") Argument_type :: #force_inline proc(self: ^Argument) -> ArgumentType { @@ -395,31 +443,31 @@ ArgumentDescriptor_argumentDescriptor :: #force_inline proc() -> ^ArgumentDescri return msgSend(^ArgumentDescriptor, ArgumentDescriptor, "argumentDescriptor") } @(objc_type=ArgumentDescriptor, objc_name="arrayLength") -ArgumentDescriptor_arrayLength :: #force_inline proc(self: ^ArgumentDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "arrayLength") +ArgumentDescriptor_arrayLength :: #force_inline proc(self: ^ArgumentDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "arrayLength") } @(objc_type=ArgumentDescriptor, objc_name="constantBlockAlignment") -ArgumentDescriptor_constantBlockAlignment :: #force_inline proc(self: ^ArgumentDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "constantBlockAlignment") +ArgumentDescriptor_constantBlockAlignment :: #force_inline proc(self: ^ArgumentDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "constantBlockAlignment") } @(objc_type=ArgumentDescriptor, objc_name="dataType") ArgumentDescriptor_dataType :: #force_inline proc(self: ^ArgumentDescriptor) -> DataType { return msgSend(DataType, self, "dataType") } @(objc_type=ArgumentDescriptor, objc_name="index") -ArgumentDescriptor_index :: #force_inline proc(self: ^ArgumentDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "index") +ArgumentDescriptor_index :: #force_inline proc(self: ^ArgumentDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "index") } @(objc_type=ArgumentDescriptor, objc_name="setAccess") ArgumentDescriptor_setAccess :: #force_inline proc(self: ^ArgumentDescriptor, access: ArgumentAccess) { msgSend(nil, self, "setAccess:", access) } @(objc_type=ArgumentDescriptor, objc_name="setArrayLength") -ArgumentDescriptor_setArrayLength :: #force_inline proc(self: ^ArgumentDescriptor, arrayLength: NS.Integer) { +ArgumentDescriptor_setArrayLength :: #force_inline proc(self: ^ArgumentDescriptor, arrayLength: NS.UInteger) { msgSend(nil, self, "setArrayLength:", arrayLength) } @(objc_type=ArgumentDescriptor, objc_name="setConstantBlockAlignment") -ArgumentDescriptor_setConstantBlockAlignment :: #force_inline proc(self: ^ArgumentDescriptor, constantBlockAlignment: NS.Integer) { +ArgumentDescriptor_setConstantBlockAlignment :: #force_inline proc(self: ^ArgumentDescriptor, constantBlockAlignment: NS.UInteger) { msgSend(nil, self, "setConstantBlockAlignment:", constantBlockAlignment) } @(objc_type=ArgumentDescriptor, objc_name="setDataType") @@ -427,7 +475,7 @@ ArgumentDescriptor_setDataType :: #force_inline proc(self: ^ArgumentDescriptor, msgSend(nil, self, "setDataType:", dataType) } @(objc_type=ArgumentDescriptor, objc_name="setIndex") -ArgumentDescriptor_setIndex :: #force_inline proc(self: ^ArgumentDescriptor, index: NS.Integer) { +ArgumentDescriptor_setIndex :: #force_inline proc(self: ^ArgumentDescriptor, index: NS.UInteger) { msgSend(nil, self, "setIndex:", index) } @(objc_type=ArgumentDescriptor, objc_name="setTextureType") @@ -469,12 +517,12 @@ ArrayType_init :: #force_inline proc(self: ^ArrayType) -> ^ArrayType { return msgSend(^ArrayType, self, "init") } @(objc_type=ArrayType, objc_name="argumentIndexStride") -ArrayType_argumentIndexStride :: #force_inline proc(self: ^ArrayType) -> NS.Integer { - return msgSend(NS.Integer, self, "argumentIndexStride") +ArrayType_argumentIndexStride :: #force_inline proc(self: ^ArrayType) -> NS.UInteger { + return msgSend(NS.UInteger, self, "argumentIndexStride") } @(objc_type=ArrayType, objc_name="arrayLength") -ArrayType_arrayLength :: #force_inline proc(self: ^ArrayType) -> NS.Integer { - return msgSend(NS.Integer, self, "arrayLength") +ArrayType_arrayLength :: #force_inline proc(self: ^ArrayType) -> NS.UInteger { + return msgSend(NS.UInteger, self, "arrayLength") } @(objc_type=ArrayType, objc_name="elementArrayType") ArrayType_elementArrayType :: #force_inline proc(self: ^ArrayType) -> ^ArrayType { @@ -497,8 +545,8 @@ ArrayType_elementType :: #force_inline proc(self: ^ArrayType) -> DataType { return msgSend(DataType, self, "elementType") } @(objc_type=ArrayType, objc_name="stride") -ArrayType_stride :: #force_inline proc(self: ^ArrayType) -> NS.Integer { - return msgSend(NS.Integer, self, "stride") +ArrayType_stride :: #force_inline proc(self: ^ArrayType) -> NS.UInteger { + return msgSend(NS.UInteger, self, "stride") } //////////////////////////////////////////////////////////////////////////////// @@ -529,8 +577,8 @@ Attribute_init :: #force_inline proc(self: ^Attribute) -> ^Attribute { return msgSend(^Attribute, self, "init") } @(objc_type=Attribute, objc_name="attributeIndex") -Attribute_attributeIndex :: #force_inline proc(self: ^Attribute) -> NS.Integer { - return msgSend(NS.Integer, self, "attributeIndex") +Attribute_attributeIndex :: #force_inline proc(self: ^Attribute) -> NS.UInteger { + return msgSend(NS.UInteger, self, "attributeIndex") } @(objc_type=Attribute, objc_name="attributeType") Attribute_attributeType :: #force_inline proc(self: ^Attribute) -> DataType { @@ -581,19 +629,19 @@ AttributeDescriptor_init :: #force_inline proc(self: ^AttributeDescriptor) -> ^A return msgSend(^AttributeDescriptor, self, "init") } @(objc_type=AttributeDescriptor, objc_name="bufferIndex") -AttributeDescriptor_bufferIndex :: #force_inline proc(self: ^AttributeDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "bufferIndex") +AttributeDescriptor_bufferIndex :: #force_inline proc(self: ^AttributeDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "bufferIndex") } @(objc_type=AttributeDescriptor, objc_name="format") AttributeDescriptor_format :: #force_inline proc(self: ^AttributeDescriptor) -> AttributeFormat { return msgSend(AttributeFormat, self, "format") } @(objc_type=AttributeDescriptor, objc_name="offset") -AttributeDescriptor_offset :: #force_inline proc(self: ^AttributeDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "offset") +AttributeDescriptor_offset :: #force_inline proc(self: ^AttributeDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "offset") } @(objc_type=AttributeDescriptor, objc_name="setBufferIndex") -AttributeDescriptor_setBufferIndex :: #force_inline proc(self: ^AttributeDescriptor, bufferIndex: NS.Integer) { +AttributeDescriptor_setBufferIndex :: #force_inline proc(self: ^AttributeDescriptor, bufferIndex: NS.UInteger) { msgSend(nil, self, "setBufferIndex:", bufferIndex) } @(objc_type=AttributeDescriptor, objc_name="setFormat") @@ -601,7 +649,7 @@ AttributeDescriptor_setFormat :: #force_inline proc(self: ^AttributeDescriptor, msgSend(nil, self, "setFormat:", format) } @(objc_type=AttributeDescriptor, objc_name="setOffset") -AttributeDescriptor_setOffset :: #force_inline proc(self: ^AttributeDescriptor, offset: NS.Integer) { +AttributeDescriptor_setOffset :: #force_inline proc(self: ^AttributeDescriptor, offset: NS.UInteger) { msgSend(nil, self, "setOffset:", offset) } @@ -629,11 +677,11 @@ AttributeDescriptorArray_init :: #force_inline proc(self: ^AttributeDescriptorAr return msgSend(^AttributeDescriptorArray, self, "init") } @(objc_type=AttributeDescriptorArray, objc_name="objectAtIndexedSubscript") -AttributeDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^AttributeDescriptorArray, index: ^NS.Object) -> ^AttributeDescriptor { +AttributeDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^AttributeDescriptorArray, index: NS.UInteger) -> ^AttributeDescriptor { return msgSend(^AttributeDescriptor, self, "objectAtIndexedSubscript:", index) } @(objc_type=AttributeDescriptorArray, objc_name="setObject") -AttributeDescriptorArray_setObject :: #force_inline proc(self: ^AttributeDescriptorArray, attributeDesc: ^AttributeDescriptor, index: ^NS.Object) { +AttributeDescriptorArray_setObject :: #force_inline proc(self: ^AttributeDescriptorArray, attributeDesc: ^AttributeDescriptor, index: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", attributeDesc, index) } @@ -729,28 +777,28 @@ BlitPassSampleBufferAttachmentDescriptor_init :: #force_inline proc(self: ^BlitP return msgSend(^BlitPassSampleBufferAttachmentDescriptor, self, "init") } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="endOfEncoderSampleIndex") -BlitPassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "endOfEncoderSampleIndex") +BlitPassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "endOfEncoderSampleIndex") } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") BlitPassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> ^BlitPassSampleBufferAttachmentDescriptor { return msgSend(^BlitPassSampleBufferAttachmentDescriptor, self, "sampleBuffer") } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex") -BlitPassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.Integer) { +BlitPassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.UInteger) { msgSend(nil, self, "setEndOfEncoderSampleIndex:", endOfEncoderSampleIndex) } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") -BlitPassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) { +BlitPassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor, sampleBuffer: ^Buffer) { msgSend(nil, self, "setSampleBuffer:", sampleBuffer) } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="setStartOfEncoderSampleIndex") -BlitPassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.Integer) { +BlitPassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.UInteger) { msgSend(nil, self, "setStartOfEncoderSampleIndex:", startOfEncoderSampleIndex) } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="startOfEncoderSampleIndex") -BlitPassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "startOfEncoderSampleIndex") +BlitPassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "startOfEncoderSampleIndex") } //////////////////////////////////////////////////////////////////////////////// @@ -777,11 +825,11 @@ BlitPassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc(self: ^ return msgSend(^BlitPassSampleBufferAttachmentDescriptorArray, self, "init") } @(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -BlitPassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^BlitPassSampleBufferAttachmentDescriptor { +BlitPassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^BlitPassSampleBufferAttachmentDescriptor { return msgSend(^BlitPassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_name="setObject") -BlitPassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray, attachment: ^BlitPassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) { +BlitPassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray, attachment: ^BlitPassSampleBufferAttachmentDescriptor, attachmentIndex: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -817,11 +865,11 @@ BufferLayoutDescriptor_setStepFunction :: #force_inline proc(self: ^BufferLayout msgSend(nil, self, "setStepFunction:", stepFunction) } @(objc_type=BufferLayoutDescriptor, objc_name="setStepRate") -BufferLayoutDescriptor_setStepRate :: #force_inline proc(self: ^BufferLayoutDescriptor, stepRate: NS.Integer) { +BufferLayoutDescriptor_setStepRate :: #force_inline proc(self: ^BufferLayoutDescriptor, stepRate: NS.UInteger) { msgSend(nil, self, "setStepRate:", stepRate) } @(objc_type=BufferLayoutDescriptor, objc_name="setStride") -BufferLayoutDescriptor_setStride :: #force_inline proc(self: ^BufferLayoutDescriptor, stride: NS.Integer) { +BufferLayoutDescriptor_setStride :: #force_inline proc(self: ^BufferLayoutDescriptor, stride: NS.UInteger) { msgSend(nil, self, "setStride:", stride) } @(objc_type=BufferLayoutDescriptor, objc_name="stepFunction") @@ -829,12 +877,12 @@ BufferLayoutDescriptor_stepFunction :: #force_inline proc(self: ^BufferLayoutDes return msgSend(StepFunction, self, "stepFunction") } @(objc_type=BufferLayoutDescriptor, objc_name="stepRate") -BufferLayoutDescriptor_stepRate :: #force_inline proc(self: ^BufferLayoutDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "stepRate") +BufferLayoutDescriptor_stepRate :: #force_inline proc(self: ^BufferLayoutDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "stepRate") } @(objc_type=BufferLayoutDescriptor, objc_name="stride") -BufferLayoutDescriptor_stride :: #force_inline proc(self: ^BufferLayoutDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "stride") +BufferLayoutDescriptor_stride :: #force_inline proc(self: ^BufferLayoutDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "stride") } //////////////////////////////////////////////////////////////////////////////// @@ -861,11 +909,11 @@ BufferLayoutDescriptorArray_init :: #force_inline proc(self: ^BufferLayoutDescri return msgSend(^BufferLayoutDescriptorArray, self, "init") } @(objc_type=BufferLayoutDescriptorArray, objc_name="objectAtIndexedSubscript") -BufferLayoutDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^BufferLayoutDescriptorArray, index: ^NS.Object) -> ^BufferLayoutDescriptor { +BufferLayoutDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^BufferLayoutDescriptorArray, index: NS.UInteger) -> ^BufferLayoutDescriptor { return msgSend(^BufferLayoutDescriptor, self, "objectAtIndexedSubscript:", index) } @(objc_type=BufferLayoutDescriptorArray, objc_name="setObject") -BufferLayoutDescriptorArray_setObject :: #force_inline proc(self: ^BufferLayoutDescriptorArray, bufferDesc: ^BufferLayoutDescriptor, index: ^NS.Object) { +BufferLayoutDescriptorArray_setObject :: #force_inline proc(self: ^BufferLayoutDescriptorArray, bufferDesc: ^BufferLayoutDescriptor, index: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", bufferDesc, index) } @@ -909,7 +957,7 @@ CaptureDescriptor_outputURL :: #force_inline proc(self: ^CaptureDescriptor) -> ^ return msgSend(^NS.URL, self, "outputURL") } @(objc_type=CaptureDescriptor, objc_name="setCaptureObject") -CaptureDescriptor_setCaptureObject :: #force_inline proc(self: ^CaptureDescriptor, captureObject: ^NS.Object) { +CaptureDescriptor_setCaptureObject :: #force_inline proc(self: ^CaptureDescriptor, captureObject: id) { msgSend(nil, self, "setCaptureObject:", captureObject) } @(objc_type=CaptureDescriptor, objc_name="setDestination") @@ -963,15 +1011,15 @@ CaptureManager_isCapturing :: #force_inline proc(self: ^CaptureManager) -> BOOL return msgSend(BOOL, self, "isCapturing") } @(objc_type=CaptureManager, objc_name="newCaptureScopeWithCommandQueue") -CaptureManager_newCaptureScopeWithCommandQueue :: #force_inline proc(self: ^CaptureManager, commandQueue: ^NS.Object) -> ^CaptureManager { +CaptureManager_newCaptureScopeWithCommandQueue :: #force_inline proc(self: ^CaptureManager, commandQueue: ^CommandQueue) -> ^CaptureManager { return msgSend(^CaptureManager, self, "newCaptureScopeWithCommandQueue:", commandQueue) } @(objc_type=CaptureManager, objc_name="newCaptureScopeWithDevice") -CaptureManager_newCaptureScopeWithDevice :: #force_inline proc(self: ^CaptureManager, device: ^NS.Object) -> ^CaptureManager { +CaptureManager_newCaptureScopeWithDevice :: #force_inline proc(self: ^CaptureManager, device: ^Device) -> ^CaptureManager { return msgSend(^CaptureManager, self, "newCaptureScopeWithDevice:", device) } @(objc_type=CaptureManager, objc_name="setDefaultCaptureScope") -CaptureManager_setDefaultCaptureScope :: #force_inline proc(self: ^CaptureManager, defaultCaptureScope: ^NS.Object) { +CaptureManager_setDefaultCaptureScope :: #force_inline proc(self: ^CaptureManager, defaultCaptureScope: ^CaptureScope) { msgSend(nil, self, "setDefaultCaptureScope:", defaultCaptureScope) } @(objc_type=CaptureManager, objc_class_name="sharedCaptureManager") @@ -979,19 +1027,20 @@ CaptureManager_sharedCaptureManager :: #force_inline proc() -> ^CaptureManager { return msgSend(^CaptureManager, CaptureManager, "sharedCaptureManager") } @(objc_type=CaptureManager, objc_name="startCaptureWithCommandQueue") -CaptureManager_startCaptureWithCommandQueue :: #force_inline proc(self: ^CaptureManager, commandQueue: ^NS.Object) { +CaptureManager_startCaptureWithCommandQueue :: #force_inline proc(self: ^CaptureManager, commandQueue: ^CommandQueue) { msgSend(nil, self, "startCaptureWithCommandQueue:", commandQueue) } @(objc_type=CaptureManager, objc_name="startCaptureWithDescriptor") -CaptureManager_startCaptureWithDescriptor :: #force_inline proc(self: ^CaptureManager, descriptor: ^CaptureDescriptor, error: ^^NS.Error ) -> BOOL { - return msgSend(BOOL, self, "startCaptureWithDescriptor:error:", descriptor, error) +CaptureManager_startCaptureWithDescriptor :: #force_inline proc(self: ^CaptureManager, descriptor: ^CaptureDescriptor) -> (ok: bool, error: ^NS.Error) { + ok = msgSend(BOOL, self, "startCaptureWithDescriptor:error:", descriptor, &error) + return } @(objc_type=CaptureManager, objc_name="startCaptureWithDevice") -CaptureManager_startCaptureWithDevice :: #force_inline proc(self: ^CaptureManager, device: ^NS.Object) { +CaptureManager_startCaptureWithDevice :: #force_inline proc(self: ^CaptureManager, device: ^Device) { msgSend(nil, self, "startCaptureWithDevice:", device) } @(objc_type=CaptureManager, objc_name="startCaptureWithScope") -CaptureManager_startCaptureWithScope :: #force_inline proc(self: ^CaptureManager, captureScope: ^NS.Object) { +CaptureManager_startCaptureWithScope :: #force_inline proc(self: ^CaptureManager, captureScope: ^CaptureScope) { msgSend(nil, self, "startCaptureWithScope:", captureScope) } @(objc_type=CaptureManager, objc_name="stopCapture") @@ -1207,28 +1256,28 @@ ComputePassSampleBufferAttachmentDescriptor_init :: #force_inline proc(self: ^Co return msgSend(^ComputePassSampleBufferAttachmentDescriptor, self, "init") } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="endOfEncoderSampleIndex") -ComputePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "endOfEncoderSampleIndex") +ComputePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "endOfEncoderSampleIndex") } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") ComputePassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> ^ComputePassSampleBufferAttachmentDescriptor { return msgSend(^ComputePassSampleBufferAttachmentDescriptor, self, "sampleBuffer") } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex") -ComputePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.Integer) { +ComputePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.UInteger) { msgSend(nil, self, "setEndOfEncoderSampleIndex:", endOfEncoderSampleIndex) } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") -ComputePassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) { +ComputePassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor, sampleBuffer: ^Buffer) { msgSend(nil, self, "setSampleBuffer:", sampleBuffer) } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="setStartOfEncoderSampleIndex") -ComputePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.Integer) { +ComputePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.UInteger) { msgSend(nil, self, "setStartOfEncoderSampleIndex:", startOfEncoderSampleIndex) } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="startOfEncoderSampleIndex") -ComputePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "startOfEncoderSampleIndex") +ComputePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "startOfEncoderSampleIndex") } //////////////////////////////////////////////////////////////////////////////// @@ -1255,11 +1304,11 @@ ComputePassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc(self return msgSend(^ComputePassSampleBufferAttachmentDescriptorArray, self, "init") } @(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -ComputePassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^ComputePassSampleBufferAttachmentDescriptor { +ComputePassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^ComputePassSampleBufferAttachmentDescriptor { return msgSend(^ComputePassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_name="setObject") -ComputePassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray, attachment: ^ComputePassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) { +ComputePassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray, attachment: ^ComputePassSampleBufferAttachmentDescriptor, attachmentIndex: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -1333,12 +1382,12 @@ ComputePipelineDescriptor_linkedFunctions :: #force_inline proc(self: ^ComputePi return msgSend(^LinkedFunctions, self, "linkedFunctions") } @(objc_type=ComputePipelineDescriptor, objc_name="maxCallStackDepth") -ComputePipelineDescriptor_maxCallStackDepth :: #force_inline proc(self: ^ComputePipelineDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "maxCallStackDepth") +ComputePipelineDescriptor_maxCallStackDepth :: #force_inline proc(self: ^ComputePipelineDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "maxCallStackDepth") } @(objc_type=ComputePipelineDescriptor, objc_name="maxTotalThreadsPerThreadgroup") -ComputePipelineDescriptor_maxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^ComputePipelineDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "maxTotalThreadsPerThreadgroup") +ComputePipelineDescriptor_maxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^ComputePipelineDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "maxTotalThreadsPerThreadgroup") } @(objc_type=ComputePipelineDescriptor, objc_name="reset") ComputePipelineDescriptor_reset :: #force_inline proc(self: ^ComputePipelineDescriptor) { @@ -1349,7 +1398,7 @@ ComputePipelineDescriptor_setBinaryArchives :: #force_inline proc(self: ^Compute msgSend(nil, self, "setBinaryArchives:", binaryArchives) } @(objc_type=ComputePipelineDescriptor, objc_name="setComputeFunction") -ComputePipelineDescriptor_setComputeFunction :: #force_inline proc(self: ^ComputePipelineDescriptor, computeFunction: ^NS.Object) { +ComputePipelineDescriptor_setComputeFunction :: #force_inline proc(self: ^ComputePipelineDescriptor, computeFunction: ^Function) { msgSend(nil, self, "setComputeFunction:", computeFunction) } @(objc_type=ComputePipelineDescriptor, objc_name="setInsertLibraries") @@ -1365,11 +1414,11 @@ ComputePipelineDescriptor_setLinkedFunctions :: #force_inline proc(self: ^Comput msgSend(nil, self, "setLinkedFunctions:", linkedFunctions) } @(objc_type=ComputePipelineDescriptor, objc_name="setMaxCallStackDepth") -ComputePipelineDescriptor_setMaxCallStackDepth :: #force_inline proc(self: ^ComputePipelineDescriptor, maxCallStackDepth: NS.Integer) { +ComputePipelineDescriptor_setMaxCallStackDepth :: #force_inline proc(self: ^ComputePipelineDescriptor, maxCallStackDepth: NS.UInteger) { msgSend(nil, self, "setMaxCallStackDepth:", maxCallStackDepth) } @(objc_type=ComputePipelineDescriptor, objc_name="setMaxTotalThreadsPerThreadgroup") -ComputePipelineDescriptor_setMaxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^ComputePipelineDescriptor, maxTotalThreadsPerThreadgroup: NS.Integer) { +ComputePipelineDescriptor_setMaxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^ComputePipelineDescriptor, maxTotalThreadsPerThreadgroup: NS.UInteger) { msgSend(nil, self, "setMaxTotalThreadsPerThreadgroup:", maxTotalThreadsPerThreadgroup) } @(objc_type=ComputePipelineDescriptor, objc_name="setStageInputDescriptor") @@ -1470,11 +1519,11 @@ CounterSampleBufferDescriptor_label :: #force_inline proc(self: ^CounterSampleBu return msgSend(^NS.String, self, "label") } @(objc_type=CounterSampleBufferDescriptor, objc_name="sampleCount") -CounterSampleBufferDescriptor_sampleCount :: #force_inline proc(self: ^CounterSampleBufferDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "sampleCount") +CounterSampleBufferDescriptor_sampleCount :: #force_inline proc(self: ^CounterSampleBufferDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "sampleCount") } @(objc_type=CounterSampleBufferDescriptor, objc_name="setCounterSet") -CounterSampleBufferDescriptor_setCounterSet :: #force_inline proc(self: ^CounterSampleBufferDescriptor, counterSet: ^NS.Object) { +CounterSampleBufferDescriptor_setCounterSet :: #force_inline proc(self: ^CounterSampleBufferDescriptor, counterSet: ^CounterSet) { msgSend(nil, self, "setCounterSet:", counterSet) } @(objc_type=CounterSampleBufferDescriptor, objc_name="setLabel") @@ -1482,7 +1531,7 @@ CounterSampleBufferDescriptor_setLabel :: #force_inline proc(self: ^CounterSampl msgSend(nil, self, "setLabel:", label) } @(objc_type=CounterSampleBufferDescriptor, objc_name="setSampleCount") -CounterSampleBufferDescriptor_setSampleCount :: #force_inline proc(self: ^CounterSampleBufferDescriptor, sampleCount: NS.Integer) { +CounterSampleBufferDescriptor_setSampleCount :: #force_inline proc(self: ^CounterSampleBufferDescriptor, sampleCount: NS.UInteger) { msgSend(nil, self, "setSampleCount:", sampleCount) } @(objc_type=CounterSampleBufferDescriptor, objc_name="setStorageMode") @@ -1592,8 +1641,8 @@ FunctionConstant_init :: #force_inline proc(self: ^FunctionConstant) -> ^Functio return msgSend(^FunctionConstant, self, "init") } @(objc_type=FunctionConstant, objc_name="index") -FunctionConstant_index :: #force_inline proc(self: ^FunctionConstant) -> NS.Integer { - return msgSend(NS.Integer, self, "index") +FunctionConstant_index :: #force_inline proc(self: ^FunctionConstant) -> NS.UInteger { + return msgSend(NS.UInteger, self, "index") } @(objc_type=FunctionConstant, objc_name="name") FunctionConstant_name :: #force_inline proc(self: ^FunctionConstant) -> ^NS.String { @@ -1637,12 +1686,12 @@ FunctionConstantValues_init :: #force_inline proc(self: ^FunctionConstantValues) FunctionConstantValues_reset :: #force_inline proc(self: ^FunctionConstantValues) { msgSend(nil, self, "reset") } -@(objc_type=FunctionConstantValues, objc_name="setConstantValue_type_atIndex_") -FunctionConstantValues_setConstantValue_type_atIndex_ :: #force_inline proc(self: ^FunctionConstantValues, value: rawptr, type: DataType, index: ^NS.Object) { +@(objc_type=FunctionConstantValues, objc_name="setConstantValueAtIndex") +FunctionConstantValues_setConstantValueAtIndex :: #force_inline proc(self: ^FunctionConstantValues, value: rawptr, type: DataType, index: NS.UInteger) { msgSend(nil, self, "setConstantValue:type:atIndex:", value, type, index) } -@(objc_type=FunctionConstantValues, objc_name="setConstantValue_type_withName_") -FunctionConstantValues_setConstantValue_type_withName_ :: #force_inline proc(self: ^FunctionConstantValues, value: rawptr, type: DataType, name: ^NS.String) { +@(objc_type=FunctionConstantValues, objc_name="setConstantValueWithName") +FunctionConstantValues_setConstantValueWithName :: #force_inline proc(self: ^FunctionConstantValues, value: rawptr, type: DataType, name: ^NS.String) { msgSend(nil, self, "setConstantValue:type:withName:", value, type, name) } @(objc_type=FunctionConstantValues, objc_name="setConstantValues") @@ -1797,7 +1846,7 @@ HeapDescriptor_setResourceOptions :: #force_inline proc(self: ^HeapDescriptor, r msgSend(nil, self, "setResourceOptions:", resourceOptions) } @(objc_type=HeapDescriptor, objc_name="setSize") -HeapDescriptor_setSize :: #force_inline proc(self: ^HeapDescriptor, size: NS.Integer) { +HeapDescriptor_setSize :: #force_inline proc(self: ^HeapDescriptor, size: NS.UInteger) { msgSend(nil, self, "setSize:", size) } @(objc_type=HeapDescriptor, objc_name="setStorageMode") @@ -1809,8 +1858,8 @@ HeapDescriptor_setType :: #force_inline proc(self: ^HeapDescriptor, type: HeapTy msgSend(nil, self, "setType:", type) } @(objc_type=HeapDescriptor, objc_name="size") -HeapDescriptor_size :: #force_inline proc(self: ^HeapDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "size") +HeapDescriptor_size :: #force_inline proc(self: ^HeapDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "size") } @(objc_type=HeapDescriptor, objc_name="storageMode") HeapDescriptor_storageMode :: #force_inline proc(self: ^HeapDescriptor) -> StorageMode { @@ -1867,16 +1916,16 @@ IndirectCommandBufferDescriptor_inheritPipelineState :: #force_inline proc(self: return msgSend(BOOL, self, "inheritPipelineState") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="maxFragmentBufferBindCount") -IndirectCommandBufferDescriptor_maxFragmentBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "maxFragmentBufferBindCount") +IndirectCommandBufferDescriptor_maxFragmentBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "maxFragmentBufferBindCount") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="maxKernelBufferBindCount") -IndirectCommandBufferDescriptor_maxKernelBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "maxKernelBufferBindCount") +IndirectCommandBufferDescriptor_maxKernelBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "maxKernelBufferBindCount") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="maxVertexBufferBindCount") -IndirectCommandBufferDescriptor_maxVertexBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "maxVertexBufferBindCount") +IndirectCommandBufferDescriptor_maxVertexBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "maxVertexBufferBindCount") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="setCommandTypes") IndirectCommandBufferDescriptor_setCommandTypes :: #force_inline proc(self: ^IndirectCommandBufferDescriptor, commandTypes: IndirectCommandType) { @@ -1891,15 +1940,15 @@ IndirectCommandBufferDescriptor_setInheritPipelineState :: #force_inline proc(se msgSend(nil, self, "setInheritPipelineState:", inheritPipelineState) } @(objc_type=IndirectCommandBufferDescriptor, objc_name="setMaxFragmentBufferBindCount") -IndirectCommandBufferDescriptor_setMaxFragmentBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor, maxFragmentBufferBindCount: NS.Integer) { +IndirectCommandBufferDescriptor_setMaxFragmentBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor, maxFragmentBufferBindCount: NS.UInteger) { msgSend(nil, self, "setMaxFragmentBufferBindCount:", maxFragmentBufferBindCount) } @(objc_type=IndirectCommandBufferDescriptor, objc_name="setMaxKernelBufferBindCount") -IndirectCommandBufferDescriptor_setMaxKernelBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor, maxKernelBufferBindCount: NS.Integer) { +IndirectCommandBufferDescriptor_setMaxKernelBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor, maxKernelBufferBindCount: NS.UInteger) { msgSend(nil, self, "setMaxKernelBufferBindCount:", maxKernelBufferBindCount) } @(objc_type=IndirectCommandBufferDescriptor, objc_name="setMaxVertexBufferBindCount") -IndirectCommandBufferDescriptor_setMaxVertexBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor, maxVertexBufferBindCount: NS.Integer) { +IndirectCommandBufferDescriptor_setMaxVertexBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor, maxVertexBufferBindCount: NS.UInteger) { msgSend(nil, self, "setMaxVertexBufferBindCount:", maxVertexBufferBindCount) } @@ -1940,39 +1989,39 @@ InstanceAccelerationStructureDescriptor_descriptor :: #force_inline proc() -> ^I return msgSend(^InstanceAccelerationStructureDescriptor, InstanceAccelerationStructureDescriptor, "descriptor") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceCount") -InstanceAccelerationStructureDescriptor_instanceCount :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "instanceCount") +InstanceAccelerationStructureDescriptor_instanceCount :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "instanceCount") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceDescriptorBuffer") InstanceAccelerationStructureDescriptor_instanceDescriptorBuffer :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> ^InstanceAccelerationStructureDescriptor { return msgSend(^InstanceAccelerationStructureDescriptor, self, "instanceDescriptorBuffer") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceDescriptorBufferOffset") -InstanceAccelerationStructureDescriptor_instanceDescriptorBufferOffset :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "instanceDescriptorBufferOffset") +InstanceAccelerationStructureDescriptor_instanceDescriptorBufferOffset :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "instanceDescriptorBufferOffset") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceDescriptorStride") -InstanceAccelerationStructureDescriptor_instanceDescriptorStride :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "instanceDescriptorStride") +InstanceAccelerationStructureDescriptor_instanceDescriptorStride :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "instanceDescriptorStride") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instancedAccelerationStructures") InstanceAccelerationStructureDescriptor_instancedAccelerationStructures :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> ^NS.Array { return msgSend(^NS.Array, self, "instancedAccelerationStructures") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceCount") -InstanceAccelerationStructureDescriptor_setInstanceCount :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, instanceCount: NS.Integer) { +InstanceAccelerationStructureDescriptor_setInstanceCount :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, instanceCount: NS.UInteger) { msgSend(nil, self, "setInstanceCount:", instanceCount) } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceDescriptorBuffer") -InstanceAccelerationStructureDescriptor_setInstanceDescriptorBuffer :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorBuffer: ^NS.Object) { +InstanceAccelerationStructureDescriptor_setInstanceDescriptorBuffer :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorBuffer: ^Buffer) { msgSend(nil, self, "setInstanceDescriptorBuffer:", instanceDescriptorBuffer) } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceDescriptorBufferOffset") -InstanceAccelerationStructureDescriptor_setInstanceDescriptorBufferOffset :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorBufferOffset: NS.Integer) { +InstanceAccelerationStructureDescriptor_setInstanceDescriptorBufferOffset :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorBufferOffset: NS.UInteger) { msgSend(nil, self, "setInstanceDescriptorBufferOffset:", instanceDescriptorBufferOffset) } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceDescriptorStride") -InstanceAccelerationStructureDescriptor_setInstanceDescriptorStride :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorStride: NS.Integer) { +InstanceAccelerationStructureDescriptor_setInstanceDescriptorStride :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorStride: NS.UInteger) { msgSend(nil, self, "setInstanceDescriptorStride:", instanceDescriptorStride) } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstancedAccelerationStructures") @@ -2005,15 +2054,15 @@ IntersectionFunctionTableDescriptor_init :: #force_inline proc(self: ^Intersecti return msgSend(^IntersectionFunctionTableDescriptor, self, "init") } @(objc_type=IntersectionFunctionTableDescriptor, objc_name="functionCount") -IntersectionFunctionTableDescriptor_functionCount :: #force_inline proc(self: ^IntersectionFunctionTableDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "functionCount") +IntersectionFunctionTableDescriptor_functionCount :: #force_inline proc(self: ^IntersectionFunctionTableDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "functionCount") } @(objc_type=IntersectionFunctionTableDescriptor, objc_class_name="intersectionFunctionTableDescriptor") IntersectionFunctionTableDescriptor_intersectionFunctionTableDescriptor :: #force_inline proc() -> ^IntersectionFunctionTableDescriptor { return msgSend(^IntersectionFunctionTableDescriptor, IntersectionFunctionTableDescriptor, "intersectionFunctionTableDescriptor") } @(objc_type=IntersectionFunctionTableDescriptor, objc_name="setFunctionCount") -IntersectionFunctionTableDescriptor_setFunctionCount :: #force_inline proc(self: ^IntersectionFunctionTableDescriptor, functionCount: NS.Integer) { +IntersectionFunctionTableDescriptor_setFunctionCount :: #force_inline proc(self: ^IntersectionFunctionTableDescriptor, functionCount: NS.UInteger) { msgSend(nil, self, "setFunctionCount:", functionCount) } @@ -2130,11 +2179,11 @@ PipelineBufferDescriptorArray_init :: #force_inline proc(self: ^PipelineBufferDe return msgSend(^PipelineBufferDescriptorArray, self, "init") } @(objc_type=PipelineBufferDescriptorArray, objc_name="objectAtIndexedSubscript") -PipelineBufferDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^PipelineBufferDescriptorArray, bufferIndex: ^NS.Object) -> ^PipelineBufferDescriptor { +PipelineBufferDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^PipelineBufferDescriptorArray, bufferIndex: NS.UInteger) -> ^PipelineBufferDescriptor { return msgSend(^PipelineBufferDescriptor, self, "objectAtIndexedSubscript:", bufferIndex) } @(objc_type=PipelineBufferDescriptorArray, objc_name="setObject") -PipelineBufferDescriptorArray_setObject :: #force_inline proc(self: ^PipelineBufferDescriptorArray, buffer: ^PipelineBufferDescriptor, bufferIndex: ^NS.Object) { +PipelineBufferDescriptorArray_setObject :: #force_inline proc(self: ^PipelineBufferDescriptorArray, buffer: ^PipelineBufferDescriptor, bufferIndex: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", buffer, bufferIndex) } @@ -2171,12 +2220,12 @@ PointerType_access :: #force_inline proc(self: ^PointerType) -> ArgumentAccess { return msgSend(ArgumentAccess, self, "access") } @(objc_type=PointerType, objc_name="alignment") -PointerType_alignment :: #force_inline proc(self: ^PointerType) -> NS.Integer { - return msgSend(NS.Integer, self, "alignment") +PointerType_alignment :: #force_inline proc(self: ^PointerType) -> NS.UInteger { + return msgSend(NS.UInteger, self, "alignment") } @(objc_type=PointerType, objc_name="dataSize") -PointerType_dataSize :: #force_inline proc(self: ^PointerType) -> NS.Integer { - return msgSend(NS.Integer, self, "dataSize") +PointerType_dataSize :: #force_inline proc(self: ^PointerType) -> NS.UInteger { + return msgSend(NS.UInteger, self, "dataSize") } @(objc_type=PointerType, objc_name="elementArrayType") PointerType_elementArrayType :: #force_inline proc(self: ^PointerType) -> ^ArrayType { @@ -2256,11 +2305,11 @@ RasterizationRateLayerArray_init :: #force_inline proc(self: ^RasterizationRateL return msgSend(^RasterizationRateLayerArray, self, "init") } @(objc_type=RasterizationRateLayerArray, objc_name="objectAtIndexedSubscript") -RasterizationRateLayerArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RasterizationRateLayerArray, layerIndex: ^NS.Object) -> ^RasterizationRateLayerDescriptor { +RasterizationRateLayerArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RasterizationRateLayerArray, layerIndex: NS.UInteger) -> ^RasterizationRateLayerDescriptor { return msgSend(^RasterizationRateLayerDescriptor, self, "objectAtIndexedSubscript:", layerIndex) } @(objc_type=RasterizationRateLayerArray, objc_name="setObject") -RasterizationRateLayerArray_setObject :: #force_inline proc(self: ^RasterizationRateLayerArray, layer: ^RasterizationRateLayerDescriptor, layerIndex: ^NS.Object) { +RasterizationRateLayerArray_setObject :: #force_inline proc(self: ^RasterizationRateLayerArray, layer: ^RasterizationRateLayerDescriptor, layerIndex: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", layer, layerIndex) } @@ -2358,12 +2407,12 @@ RasterizationRateMapDescriptor_label :: #force_inline proc(self: ^RasterizationR return msgSend(^NS.String, self, "label") } @(objc_type=RasterizationRateMapDescriptor, objc_name="layerAtIndex") -RasterizationRateMapDescriptor_layerAtIndex :: #force_inline proc(self: ^RasterizationRateMapDescriptor, layerIndex: ^NS.Object) -> ^RasterizationRateLayerDescriptor { +RasterizationRateMapDescriptor_layerAtIndex :: #force_inline proc(self: ^RasterizationRateMapDescriptor, layerIndex: NS.UInteger) -> ^RasterizationRateLayerDescriptor { return msgSend(^RasterizationRateLayerDescriptor, self, "layerAtIndex:", layerIndex) } @(objc_type=RasterizationRateMapDescriptor, objc_name="layerCount") -RasterizationRateMapDescriptor_layerCount :: #force_inline proc(self: ^RasterizationRateMapDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "layerCount") +RasterizationRateMapDescriptor_layerCount :: #force_inline proc(self: ^RasterizationRateMapDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "layerCount") } @(objc_type=RasterizationRateMapDescriptor, objc_name="layers") RasterizationRateMapDescriptor_layers :: #force_inline proc(self: ^RasterizationRateMapDescriptor) -> ^RasterizationRateLayerArray { @@ -2373,12 +2422,12 @@ RasterizationRateMapDescriptor_layers :: #force_inline proc(self: ^Rasterization RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize :: #force_inline proc(screenSize: Size) -> ^RasterizationRateMapDescriptor { return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:", screenSize) } -@(objc_type=RasterizationRateMapDescriptor, objc_class_name="rasterizationRateMapDescriptorWithScreenSize_layer_") -RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize_layer_ :: #force_inline proc(screenSize: Size, layer: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateMapDescriptor { +@(objc_type=RasterizationRateMapDescriptor, objc_class_name="rasterizationRateMapDescriptorWithScreenSizeWithLayer") +RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSizeWithLayer :: #force_inline proc(screenSize: Size, layer: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateMapDescriptor { return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:layer:", screenSize, layer) } -@(objc_type=RasterizationRateMapDescriptor, objc_class_name="rasterizationRateMapDescriptorWithScreenSize_layerCount_layers_") -RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize_layerCount_layers_ :: #force_inline proc(screenSize: Size, layerCount: ^NS.Object, layers: ^^RasterizationRateLayerDescriptor ) -> ^RasterizationRateMapDescriptor { +@(objc_type=RasterizationRateMapDescriptor, objc_class_name="rasterizationRateMapDescriptorWithScreenSizeWithLayers") +RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSizeWithLayers :: #force_inline proc(screenSize: Size, layerCount: NS.UInteger, layers: [^]^RasterizationRateLayerDescriptor) -> ^RasterizationRateMapDescriptor { return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:layerCount:layers:", screenSize, layerCount, layers) } @(objc_type=RasterizationRateMapDescriptor, objc_name="screenSize") @@ -2390,7 +2439,7 @@ RasterizationRateMapDescriptor_setLabel :: #force_inline proc(self: ^Rasterizati msgSend(nil, self, "setLabel:", label) } @(objc_type=RasterizationRateMapDescriptor, objc_name="setLayer") -RasterizationRateMapDescriptor_setLayer :: #force_inline proc(self: ^RasterizationRateMapDescriptor, layer: ^RasterizationRateLayerDescriptor, layerIndex: ^NS.Object) { +RasterizationRateMapDescriptor_setLayer :: #force_inline proc(self: ^RasterizationRateMapDescriptor, layer: ^RasterizationRateLayerDescriptor, layerIndex: NS.UInteger) { msgSend(nil, self, "setLayer:atIndex:", layer, layerIndex) } @(objc_type=RasterizationRateMapDescriptor, objc_name="setScreenSize") @@ -2422,11 +2471,11 @@ RasterizationRateSampleArray_init :: #force_inline proc(self: ^RasterizationRate return msgSend(^RasterizationRateSampleArray, self, "init") } @(objc_type=RasterizationRateSampleArray, objc_name="objectAtIndexedSubscript") -RasterizationRateSampleArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RasterizationRateSampleArray, index: ^NS.Object) -> ^NS.Number { - return msgSend(^NS.Number, self, "objectAtIndexedSubscript:", index) +RasterizationRateSampleArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RasterizationRateSampleArray, index: NS.UInteger) -> NS.UInteger { + return msgSend(NS.UInteger, self, "objectAtIndexedSubscript:", index) } @(objc_type=RasterizationRateSampleArray, objc_name="setObject") -RasterizationRateSampleArray_setObject :: #force_inline proc(self: ^RasterizationRateSampleArray, value: ^NS.Number, index: ^NS.Object) { +RasterizationRateSampleArray_setObject :: #force_inline proc(self: ^RasterizationRateSampleArray, value: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", value, index) } @@ -2474,39 +2523,39 @@ RenderPassAttachmentDescriptor_init :: #force_inline proc(self: ^RenderPassAttac return msgSend(^RenderPassAttachmentDescriptor, self, "init") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="depthPlane") -RenderPassAttachmentDescriptor_depthPlane :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "depthPlane") +RenderPassAttachmentDescriptor_depthPlane :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "depthPlane") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="level") -RenderPassAttachmentDescriptor_level :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "level") +RenderPassAttachmentDescriptor_level :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "level") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="loadAction") RenderPassAttachmentDescriptor_loadAction :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> LoadAction { return msgSend(LoadAction, self, "loadAction") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveDepthPlane") -RenderPassAttachmentDescriptor_resolveDepthPlane :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "resolveDepthPlane") +RenderPassAttachmentDescriptor_resolveDepthPlane :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "resolveDepthPlane") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveLevel") -RenderPassAttachmentDescriptor_resolveLevel :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "resolveLevel") +RenderPassAttachmentDescriptor_resolveLevel :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "resolveLevel") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveSlice") -RenderPassAttachmentDescriptor_resolveSlice :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "resolveSlice") +RenderPassAttachmentDescriptor_resolveSlice :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "resolveSlice") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveTexture") RenderPassAttachmentDescriptor_resolveTexture :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> ^RenderPassAttachmentDescriptor { return msgSend(^RenderPassAttachmentDescriptor, self, "resolveTexture") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setDepthPlane") -RenderPassAttachmentDescriptor_setDepthPlane :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, depthPlane: NS.Integer) { +RenderPassAttachmentDescriptor_setDepthPlane :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, depthPlane: NS.UInteger) { msgSend(nil, self, "setDepthPlane:", depthPlane) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setLevel") -RenderPassAttachmentDescriptor_setLevel :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, level: NS.Integer) { +RenderPassAttachmentDescriptor_setLevel :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, level: NS.UInteger) { msgSend(nil, self, "setLevel:", level) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setLoadAction") @@ -2514,23 +2563,23 @@ RenderPassAttachmentDescriptor_setLoadAction :: #force_inline proc(self: ^Render msgSend(nil, self, "setLoadAction:", loadAction) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveDepthPlane") -RenderPassAttachmentDescriptor_setResolveDepthPlane :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, resolveDepthPlane: NS.Integer) { +RenderPassAttachmentDescriptor_setResolveDepthPlane :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, resolveDepthPlane: NS.UInteger) { msgSend(nil, self, "setResolveDepthPlane:", resolveDepthPlane) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveLevel") -RenderPassAttachmentDescriptor_setResolveLevel :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, resolveLevel: NS.Integer) { +RenderPassAttachmentDescriptor_setResolveLevel :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, resolveLevel: NS.UInteger) { msgSend(nil, self, "setResolveLevel:", resolveLevel) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveSlice") -RenderPassAttachmentDescriptor_setResolveSlice :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, resolveSlice: NS.Integer) { +RenderPassAttachmentDescriptor_setResolveSlice :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, resolveSlice: NS.UInteger) { msgSend(nil, self, "setResolveSlice:", resolveSlice) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveTexture") -RenderPassAttachmentDescriptor_setResolveTexture :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, resolveTexture: ^NS.Object) { +RenderPassAttachmentDescriptor_setResolveTexture :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, resolveTexture: ^Texture) { msgSend(nil, self, "setResolveTexture:", resolveTexture) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setSlice") -RenderPassAttachmentDescriptor_setSlice :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, slice: NS.Integer) { +RenderPassAttachmentDescriptor_setSlice :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, slice: NS.UInteger) { msgSend(nil, self, "setSlice:", slice) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setStoreAction") @@ -2542,12 +2591,12 @@ RenderPassAttachmentDescriptor_setStoreActionOptions :: #force_inline proc(self: msgSend(nil, self, "setStoreActionOptions:", storeActionOptions) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setTexture") -RenderPassAttachmentDescriptor_setTexture :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, texture: ^NS.Object) { +RenderPassAttachmentDescriptor_setTexture :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, texture: ^Texture) { msgSend(nil, self, "setTexture:", texture) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="slice") -RenderPassAttachmentDescriptor_slice :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "slice") +RenderPassAttachmentDescriptor_slice :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "slice") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="storeAction") RenderPassAttachmentDescriptor_storeAction :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> StoreAction { @@ -2618,11 +2667,11 @@ RenderPassColorAttachmentDescriptorArray_init :: #force_inline proc(self: ^Rende return msgSend(^RenderPassColorAttachmentDescriptorArray, self, "init") } @(objc_type=RenderPassColorAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -RenderPassColorAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RenderPassColorAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^RenderPassColorAttachmentDescriptor { +RenderPassColorAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RenderPassColorAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^RenderPassColorAttachmentDescriptor { return msgSend(^RenderPassColorAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=RenderPassColorAttachmentDescriptorArray, objc_name="setObject") -RenderPassColorAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^RenderPassColorAttachmentDescriptorArray, attachment: ^RenderPassColorAttachmentDescriptor, attachmentIndex: ^NS.Object) { +RenderPassColorAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^RenderPassColorAttachmentDescriptorArray, attachment: ^RenderPassColorAttachmentDescriptor, attachmentIndex: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -2723,20 +2772,20 @@ RenderPassDescriptor_colorAttachments :: #force_inline proc(self: ^RenderPassDes return msgSend(^RenderPassColorAttachmentDescriptorArray, self, "colorAttachments") } @(objc_type=RenderPassDescriptor, objc_name="defaultRasterSampleCount") -RenderPassDescriptor_defaultRasterSampleCount :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "defaultRasterSampleCount") +RenderPassDescriptor_defaultRasterSampleCount :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "defaultRasterSampleCount") } @(objc_type=RenderPassDescriptor, objc_name="depthAttachment") RenderPassDescriptor_depthAttachment :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RenderPassDepthAttachmentDescriptor { return msgSend(^RenderPassDepthAttachmentDescriptor, self, "depthAttachment") } @(objc_type=RenderPassDescriptor, objc_name="getSamplePositions") -RenderPassDescriptor_getSamplePositions :: #force_inline proc(self: ^RenderPassDescriptor, positions: ^SamplePosition, count: ^NS.Object) -> ^RenderPassDescriptor { +RenderPassDescriptor_getSamplePositions :: #force_inline proc(self: ^RenderPassDescriptor, positions: ^SamplePosition, count: NS.UInteger) -> ^RenderPassDescriptor { return msgSend(^RenderPassDescriptor, self, "getSamplePositions:count:", positions, count) } @(objc_type=RenderPassDescriptor, objc_name="imageblockSampleLength") -RenderPassDescriptor_imageblockSampleLength :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "imageblockSampleLength") +RenderPassDescriptor_imageblockSampleLength :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "imageblockSampleLength") } @(objc_type=RenderPassDescriptor, objc_name="rasterizationRateMap") RenderPassDescriptor_rasterizationRateMap :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RenderPassDescriptor { @@ -2747,23 +2796,23 @@ RenderPassDescriptor_renderPassDescriptor :: #force_inline proc() -> ^RenderPass return msgSend(^RenderPassDescriptor, RenderPassDescriptor, "renderPassDescriptor") } @(objc_type=RenderPassDescriptor, objc_name="renderTargetArrayLength") -RenderPassDescriptor_renderTargetArrayLength :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "renderTargetArrayLength") +RenderPassDescriptor_renderTargetArrayLength :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "renderTargetArrayLength") } @(objc_type=RenderPassDescriptor, objc_name="renderTargetHeight") -RenderPassDescriptor_renderTargetHeight :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "renderTargetHeight") +RenderPassDescriptor_renderTargetHeight :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "renderTargetHeight") } @(objc_type=RenderPassDescriptor, objc_name="renderTargetWidth") -RenderPassDescriptor_renderTargetWidth :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "renderTargetWidth") +RenderPassDescriptor_renderTargetWidth :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "renderTargetWidth") } @(objc_type=RenderPassDescriptor, objc_name="sampleBufferAttachments") RenderPassDescriptor_sampleBufferAttachments :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RenderPassSampleBufferAttachmentDescriptorArray { return msgSend(^RenderPassSampleBufferAttachmentDescriptorArray, self, "sampleBufferAttachments") } @(objc_type=RenderPassDescriptor, objc_name="setDefaultRasterSampleCount") -RenderPassDescriptor_setDefaultRasterSampleCount :: #force_inline proc(self: ^RenderPassDescriptor, defaultRasterSampleCount: NS.Integer) { +RenderPassDescriptor_setDefaultRasterSampleCount :: #force_inline proc(self: ^RenderPassDescriptor, defaultRasterSampleCount: NS.UInteger) { msgSend(nil, self, "setDefaultRasterSampleCount:", defaultRasterSampleCount) } @(objc_type=RenderPassDescriptor, objc_name="setDepthAttachment") @@ -2771,27 +2820,27 @@ RenderPassDescriptor_setDepthAttachment :: #force_inline proc(self: ^RenderPassD msgSend(nil, self, "setDepthAttachment:", depthAttachment) } @(objc_type=RenderPassDescriptor, objc_name="setImageblockSampleLength") -RenderPassDescriptor_setImageblockSampleLength :: #force_inline proc(self: ^RenderPassDescriptor, imageblockSampleLength: NS.Integer) { +RenderPassDescriptor_setImageblockSampleLength :: #force_inline proc(self: ^RenderPassDescriptor, imageblockSampleLength: NS.UInteger) { msgSend(nil, self, "setImageblockSampleLength:", imageblockSampleLength) } @(objc_type=RenderPassDescriptor, objc_name="setRasterizationRateMap") -RenderPassDescriptor_setRasterizationRateMap :: #force_inline proc(self: ^RenderPassDescriptor, rasterizationRateMap: ^NS.Object) { +RenderPassDescriptor_setRasterizationRateMap :: #force_inline proc(self: ^RenderPassDescriptor, rasterizationRateMap: ^RasterizationRateMap) { msgSend(nil, self, "setRasterizationRateMap:", rasterizationRateMap) } @(objc_type=RenderPassDescriptor, objc_name="setRenderTargetArrayLength") -RenderPassDescriptor_setRenderTargetArrayLength :: #force_inline proc(self: ^RenderPassDescriptor, renderTargetArrayLength: NS.Integer) { +RenderPassDescriptor_setRenderTargetArrayLength :: #force_inline proc(self: ^RenderPassDescriptor, renderTargetArrayLength: NS.UInteger) { msgSend(nil, self, "setRenderTargetArrayLength:", renderTargetArrayLength) } @(objc_type=RenderPassDescriptor, objc_name="setRenderTargetHeight") -RenderPassDescriptor_setRenderTargetHeight :: #force_inline proc(self: ^RenderPassDescriptor, renderTargetHeight: NS.Integer) { +RenderPassDescriptor_setRenderTargetHeight :: #force_inline proc(self: ^RenderPassDescriptor, renderTargetHeight: NS.UInteger) { msgSend(nil, self, "setRenderTargetHeight:", renderTargetHeight) } @(objc_type=RenderPassDescriptor, objc_name="setRenderTargetWidth") -RenderPassDescriptor_setRenderTargetWidth :: #force_inline proc(self: ^RenderPassDescriptor, renderTargetWidth: NS.Integer) { +RenderPassDescriptor_setRenderTargetWidth :: #force_inline proc(self: ^RenderPassDescriptor, renderTargetWidth: NS.UInteger) { msgSend(nil, self, "setRenderTargetWidth:", renderTargetWidth) } @(objc_type=RenderPassDescriptor, objc_name="setSamplePositions") -RenderPassDescriptor_setSamplePositions :: #force_inline proc(self: ^RenderPassDescriptor, positions: ^SamplePosition, count: ^NS.Object) { +RenderPassDescriptor_setSamplePositions :: #force_inline proc(self: ^RenderPassDescriptor, positions: ^SamplePosition, count: NS.UInteger) { msgSend(nil, self, "setSamplePositions:count:", positions, count) } @(objc_type=RenderPassDescriptor, objc_name="setStencilAttachment") @@ -2799,19 +2848,19 @@ RenderPassDescriptor_setStencilAttachment :: #force_inline proc(self: ^RenderPas msgSend(nil, self, "setStencilAttachment:", stencilAttachment) } @(objc_type=RenderPassDescriptor, objc_name="setThreadgroupMemoryLength") -RenderPassDescriptor_setThreadgroupMemoryLength :: #force_inline proc(self: ^RenderPassDescriptor, threadgroupMemoryLength: NS.Integer) { +RenderPassDescriptor_setThreadgroupMemoryLength :: #force_inline proc(self: ^RenderPassDescriptor, threadgroupMemoryLength: NS.UInteger) { msgSend(nil, self, "setThreadgroupMemoryLength:", threadgroupMemoryLength) } @(objc_type=RenderPassDescriptor, objc_name="setTileHeight") -RenderPassDescriptor_setTileHeight :: #force_inline proc(self: ^RenderPassDescriptor, tileHeight: NS.Integer) { +RenderPassDescriptor_setTileHeight :: #force_inline proc(self: ^RenderPassDescriptor, tileHeight: NS.UInteger) { msgSend(nil, self, "setTileHeight:", tileHeight) } @(objc_type=RenderPassDescriptor, objc_name="setTileWidth") -RenderPassDescriptor_setTileWidth :: #force_inline proc(self: ^RenderPassDescriptor, tileWidth: NS.Integer) { +RenderPassDescriptor_setTileWidth :: #force_inline proc(self: ^RenderPassDescriptor, tileWidth: NS.UInteger) { msgSend(nil, self, "setTileWidth:", tileWidth) } @(objc_type=RenderPassDescriptor, objc_name="setVisibilityResultBuffer") -RenderPassDescriptor_setVisibilityResultBuffer :: #force_inline proc(self: ^RenderPassDescriptor, visibilityResultBuffer: ^NS.Object) { +RenderPassDescriptor_setVisibilityResultBuffer :: #force_inline proc(self: ^RenderPassDescriptor, visibilityResultBuffer: ^Buffer) { msgSend(nil, self, "setVisibilityResultBuffer:", visibilityResultBuffer) } @(objc_type=RenderPassDescriptor, objc_name="stencilAttachment") @@ -2819,16 +2868,16 @@ RenderPassDescriptor_stencilAttachment :: #force_inline proc(self: ^RenderPassDe return msgSend(^RenderPassStencilAttachmentDescriptor, self, "stencilAttachment") } @(objc_type=RenderPassDescriptor, objc_name="threadgroupMemoryLength") -RenderPassDescriptor_threadgroupMemoryLength :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "threadgroupMemoryLength") +RenderPassDescriptor_threadgroupMemoryLength :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "threadgroupMemoryLength") } @(objc_type=RenderPassDescriptor, objc_name="tileHeight") -RenderPassDescriptor_tileHeight :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "tileHeight") +RenderPassDescriptor_tileHeight :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "tileHeight") } @(objc_type=RenderPassDescriptor, objc_name="tileWidth") -RenderPassDescriptor_tileWidth :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "tileWidth") +RenderPassDescriptor_tileWidth :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "tileWidth") } @(objc_type=RenderPassDescriptor, objc_name="visibilityResultBuffer") RenderPassDescriptor_visibilityResultBuffer :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RenderPassDescriptor { @@ -2867,44 +2916,44 @@ RenderPassSampleBufferAttachmentDescriptor_init :: #force_inline proc(self: ^Ren return msgSend(^RenderPassSampleBufferAttachmentDescriptor, self, "init") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="endOfFragmentSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_endOfFragmentSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "endOfFragmentSampleIndex") +RenderPassSampleBufferAttachmentDescriptor_endOfFragmentSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "endOfFragmentSampleIndex") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="endOfVertexSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_endOfVertexSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "endOfVertexSampleIndex") +RenderPassSampleBufferAttachmentDescriptor_endOfVertexSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "endOfVertexSampleIndex") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") RenderPassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> ^RenderPassSampleBufferAttachmentDescriptor { return msgSend(^RenderPassSampleBufferAttachmentDescriptor, self, "sampleBuffer") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setEndOfFragmentSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_setEndOfFragmentSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, endOfFragmentSampleIndex: NS.Integer) { +RenderPassSampleBufferAttachmentDescriptor_setEndOfFragmentSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, endOfFragmentSampleIndex: NS.UInteger) { msgSend(nil, self, "setEndOfFragmentSampleIndex:", endOfFragmentSampleIndex) } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setEndOfVertexSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_setEndOfVertexSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, endOfVertexSampleIndex: NS.Integer) { +RenderPassSampleBufferAttachmentDescriptor_setEndOfVertexSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, endOfVertexSampleIndex: NS.UInteger) { msgSend(nil, self, "setEndOfVertexSampleIndex:", endOfVertexSampleIndex) } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") -RenderPassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) { +RenderPassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, sampleBuffer: ^Buffer) { msgSend(nil, self, "setSampleBuffer:", sampleBuffer) } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setStartOfFragmentSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_setStartOfFragmentSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, startOfFragmentSampleIndex: NS.Integer) { +RenderPassSampleBufferAttachmentDescriptor_setStartOfFragmentSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, startOfFragmentSampleIndex: NS.UInteger) { msgSend(nil, self, "setStartOfFragmentSampleIndex:", startOfFragmentSampleIndex) } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setStartOfVertexSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_setStartOfVertexSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, startOfVertexSampleIndex: NS.Integer) { +RenderPassSampleBufferAttachmentDescriptor_setStartOfVertexSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, startOfVertexSampleIndex: NS.UInteger) { msgSend(nil, self, "setStartOfVertexSampleIndex:", startOfVertexSampleIndex) } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="startOfFragmentSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_startOfFragmentSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "startOfFragmentSampleIndex") +RenderPassSampleBufferAttachmentDescriptor_startOfFragmentSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "startOfFragmentSampleIndex") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="startOfVertexSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_startOfVertexSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "startOfVertexSampleIndex") +RenderPassSampleBufferAttachmentDescriptor_startOfVertexSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "startOfVertexSampleIndex") } //////////////////////////////////////////////////////////////////////////////// @@ -2931,11 +2980,11 @@ RenderPassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc(self: return msgSend(^RenderPassSampleBufferAttachmentDescriptorArray, self, "init") } @(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -RenderPassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^RenderPassSampleBufferAttachmentDescriptor { +RenderPassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^RenderPassSampleBufferAttachmentDescriptor { return msgSend(^RenderPassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_name="setObject") -RenderPassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray, attachment: ^RenderPassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) { +RenderPassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray, attachment: ^RenderPassSampleBufferAttachmentDescriptor, attachmentIndex: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -3117,11 +3166,11 @@ RenderPipelineColorAttachmentDescriptorArray_init :: #force_inline proc(self: ^R return msgSend(^RenderPipelineColorAttachmentDescriptorArray, self, "init") } @(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -RenderPipelineColorAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^RenderPipelineColorAttachmentDescriptor { +RenderPipelineColorAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^RenderPipelineColorAttachmentDescriptor { return msgSend(^RenderPipelineColorAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_name="setObject") -RenderPipelineColorAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptorArray, attachment: ^RenderPipelineColorAttachmentDescriptor, attachmentIndex: ^NS.Object) { +RenderPipelineColorAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptorArray, attachment: ^RenderPipelineColorAttachmentDescriptor, attachmentIndex: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -3239,24 +3288,24 @@ RenderPipelineDescriptor_label :: #force_inline proc(self: ^RenderPipelineDescri return msgSend(^NS.String, self, "label") } @(objc_type=RenderPipelineDescriptor, objc_name="maxTessellationFactor") -RenderPipelineDescriptor_maxTessellationFactor :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "maxTessellationFactor") +RenderPipelineDescriptor_maxTessellationFactor :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "maxTessellationFactor") } @(objc_type=RenderPipelineDescriptor, objc_name="maxVertexAmplificationCount") -RenderPipelineDescriptor_maxVertexAmplificationCount :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "maxVertexAmplificationCount") +RenderPipelineDescriptor_maxVertexAmplificationCount :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "maxVertexAmplificationCount") } @(objc_type=RenderPipelineDescriptor, objc_name="rasterSampleCount") -RenderPipelineDescriptor_rasterSampleCount :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "rasterSampleCount") +RenderPipelineDescriptor_rasterSampleCount :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "rasterSampleCount") } @(objc_type=RenderPipelineDescriptor, objc_name="reset") RenderPipelineDescriptor_reset :: #force_inline proc(self: ^RenderPipelineDescriptor) { msgSend(nil, self, "reset") } @(objc_type=RenderPipelineDescriptor, objc_name="sampleCount") -RenderPipelineDescriptor_sampleCount :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "sampleCount") +RenderPipelineDescriptor_sampleCount :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "sampleCount") } @(objc_type=RenderPipelineDescriptor, objc_name="setAlphaToCoverageEnabled") RenderPipelineDescriptor_setAlphaToCoverageEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor, alphaToCoverageEnabled: BOOL) { @@ -3275,7 +3324,7 @@ RenderPipelineDescriptor_setDepthAttachmentPixelFormat :: #force_inline proc(sel msgSend(nil, self, "setDepthAttachmentPixelFormat:", depthAttachmentPixelFormat) } @(objc_type=RenderPipelineDescriptor, objc_name="setFragmentFunction") -RenderPipelineDescriptor_setFragmentFunction :: #force_inline proc(self: ^RenderPipelineDescriptor, fragmentFunction: ^NS.Object) { +RenderPipelineDescriptor_setFragmentFunction :: #force_inline proc(self: ^RenderPipelineDescriptor, fragmentFunction: ^Function) { msgSend(nil, self, "setFragmentFunction:", fragmentFunction) } @(objc_type=RenderPipelineDescriptor, objc_name="setInputPrimitiveTopology") @@ -3287,15 +3336,15 @@ RenderPipelineDescriptor_setLabel :: #force_inline proc(self: ^RenderPipelineDes msgSend(nil, self, "setLabel:", label) } @(objc_type=RenderPipelineDescriptor, objc_name="setMaxTessellationFactor") -RenderPipelineDescriptor_setMaxTessellationFactor :: #force_inline proc(self: ^RenderPipelineDescriptor, maxTessellationFactor: NS.Integer) { +RenderPipelineDescriptor_setMaxTessellationFactor :: #force_inline proc(self: ^RenderPipelineDescriptor, maxTessellationFactor: NS.UInteger) { msgSend(nil, self, "setMaxTessellationFactor:", maxTessellationFactor) } @(objc_type=RenderPipelineDescriptor, objc_name="setMaxVertexAmplificationCount") -RenderPipelineDescriptor_setMaxVertexAmplificationCount :: #force_inline proc(self: ^RenderPipelineDescriptor, maxVertexAmplificationCount: NS.Integer) { +RenderPipelineDescriptor_setMaxVertexAmplificationCount :: #force_inline proc(self: ^RenderPipelineDescriptor, maxVertexAmplificationCount: NS.UInteger) { msgSend(nil, self, "setMaxVertexAmplificationCount:", maxVertexAmplificationCount) } @(objc_type=RenderPipelineDescriptor, objc_name="setRasterSampleCount") -RenderPipelineDescriptor_setRasterSampleCount :: #force_inline proc(self: ^RenderPipelineDescriptor, rasterSampleCount: NS.Integer) { +RenderPipelineDescriptor_setRasterSampleCount :: #force_inline proc(self: ^RenderPipelineDescriptor, rasterSampleCount: NS.UInteger) { msgSend(nil, self, "setRasterSampleCount:", rasterSampleCount) } @(objc_type=RenderPipelineDescriptor, objc_name="setRasterizationEnabled") @@ -3303,7 +3352,7 @@ RenderPipelineDescriptor_setRasterizationEnabled :: #force_inline proc(self: ^Re msgSend(nil, self, "setRasterizationEnabled:", rasterizationEnabled) } @(objc_type=RenderPipelineDescriptor, objc_name="setSampleCount") -RenderPipelineDescriptor_setSampleCount :: #force_inline proc(self: ^RenderPipelineDescriptor, sampleCount: NS.Integer) { +RenderPipelineDescriptor_setSampleCount :: #force_inline proc(self: ^RenderPipelineDescriptor, sampleCount: NS.UInteger) { msgSend(nil, self, "setSampleCount:", sampleCount) } @(objc_type=RenderPipelineDescriptor, objc_name="setStencilAttachmentPixelFormat") @@ -3343,7 +3392,7 @@ RenderPipelineDescriptor_setVertexDescriptor :: #force_inline proc(self: ^Render msgSend(nil, self, "setVertexDescriptor:", vertexDescriptor) } @(objc_type=RenderPipelineDescriptor, objc_name="setVertexFunction") -RenderPipelineDescriptor_setVertexFunction :: #force_inline proc(self: ^RenderPipelineDescriptor, vertexFunction: ^NS.Object) { +RenderPipelineDescriptor_setVertexFunction :: #force_inline proc(self: ^RenderPipelineDescriptor, vertexFunction: ^Function) { msgSend(nil, self, "setVertexFunction:", vertexFunction) } @(objc_type=RenderPipelineDescriptor, objc_name="stencilAttachmentPixelFormat") @@ -3484,28 +3533,28 @@ ResourceStatePassSampleBufferAttachmentDescriptor_init :: #force_inline proc(sel return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, self, "init") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="endOfEncoderSampleIndex") -ResourceStatePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "endOfEncoderSampleIndex") +ResourceStatePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "endOfEncoderSampleIndex") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") ResourceStatePassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> ^ResourceStatePassSampleBufferAttachmentDescriptor { return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, self, "sampleBuffer") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex") -ResourceStatePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.Integer) { +ResourceStatePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.UInteger) { msgSend(nil, self, "setEndOfEncoderSampleIndex:", endOfEncoderSampleIndex) } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") -ResourceStatePassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) { +ResourceStatePassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, sampleBuffer: ^Buffer) { msgSend(nil, self, "setSampleBuffer:", sampleBuffer) } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="setStartOfEncoderSampleIndex") -ResourceStatePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.Integer) { +ResourceStatePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.UInteger) { msgSend(nil, self, "setStartOfEncoderSampleIndex:", startOfEncoderSampleIndex) } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="startOfEncoderSampleIndex") -ResourceStatePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "startOfEncoderSampleIndex") +ResourceStatePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "startOfEncoderSampleIndex") } //////////////////////////////////////////////////////////////////////////////// @@ -3532,11 +3581,11 @@ ResourceStatePassSampleBufferAttachmentDescriptorArray_init :: #force_inline pro return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptorArray, self, "init") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -ResourceStatePassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^ResourceStatePassSampleBufferAttachmentDescriptor { +ResourceStatePassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^ResourceStatePassSampleBufferAttachmentDescriptor { return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_name="setObject") -ResourceStatePassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray, attachment: ^ResourceStatePassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) { +ResourceStatePassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray, attachment: ^ResourceStatePassSampleBufferAttachmentDescriptor, attachmentIndex: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -3620,8 +3669,8 @@ SamplerDescriptor_magFilter :: #force_inline proc(self: ^SamplerDescriptor) -> S return msgSend(SamplerMinMagFilter, self, "magFilter") } @(objc_type=SamplerDescriptor, objc_name="maxAnisotropy") -SamplerDescriptor_maxAnisotropy :: #force_inline proc(self: ^SamplerDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "maxAnisotropy") +SamplerDescriptor_maxAnisotropy :: #force_inline proc(self: ^SamplerDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "maxAnisotropy") } @(objc_type=SamplerDescriptor, objc_name="minFilter") SamplerDescriptor_minFilter :: #force_inline proc(self: ^SamplerDescriptor) -> SamplerMinMagFilter { @@ -3672,7 +3721,7 @@ SamplerDescriptor_setMagFilter :: #force_inline proc(self: ^SamplerDescriptor, m msgSend(nil, self, "setMagFilter:", magFilter) } @(objc_type=SamplerDescriptor, objc_name="setMaxAnisotropy") -SamplerDescriptor_setMaxAnisotropy :: #force_inline proc(self: ^SamplerDescriptor, maxAnisotropy: NS.Integer) { +SamplerDescriptor_setMaxAnisotropy :: #force_inline proc(self: ^SamplerDescriptor, maxAnisotropy: NS.UInteger) { msgSend(nil, self, "setMaxAnisotropy:", maxAnisotropy) } @(objc_type=SamplerDescriptor, objc_name="setMinFilter") @@ -3759,15 +3808,15 @@ SharedEventListener_alloc :: #force_inline proc() -> ^SharedEventListener { return msgSend(^SharedEventListener, SharedEventListener, "alloc") } @(objc_type=SharedEventListener, objc_name="dispatchQueue") -SharedEventListener_dispatchQueue :: #force_inline proc(self: ^SharedEventListener) -> NS.Integer { - return msgSend(NS.Integer, self, "dispatchQueue") +SharedEventListener_dispatchQueue :: #force_inline proc(self: ^SharedEventListener) -> NS.UInteger { + return msgSend(NS.UInteger, self, "dispatchQueue") } @(objc_type=SharedEventListener, objc_name="init") SharedEventListener_init :: #force_inline proc(self: ^SharedEventListener) -> ^SharedEventListener { return msgSend(^SharedEventListener, self, "init") } @(objc_type=SharedEventListener, objc_name="initWithDispatchQueue") -SharedEventListener_initWithDispatchQueue :: #force_inline proc(self: ^SharedEventListener, dispatchQueue: ^NS.Object) -> ^SharedEventListener { +SharedEventListener_initWithDispatchQueue :: #force_inline proc(self: ^SharedEventListener, dispatchQueue: dispatch_queue_t) -> ^SharedEventListener { return msgSend(^SharedEventListener, self, "initWithDispatchQueue:", dispatchQueue) } @@ -3837,8 +3886,8 @@ StageInputOutputDescriptor_attributes :: #force_inline proc(self: ^StageInputOut return msgSend(^AttributeDescriptorArray, self, "attributes") } @(objc_type=StageInputOutputDescriptor, objc_name="indexBufferIndex") -StageInputOutputDescriptor_indexBufferIndex :: #force_inline proc(self: ^StageInputOutputDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "indexBufferIndex") +StageInputOutputDescriptor_indexBufferIndex :: #force_inline proc(self: ^StageInputOutputDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "indexBufferIndex") } @(objc_type=StageInputOutputDescriptor, objc_name="indexType") StageInputOutputDescriptor_indexType :: #force_inline proc(self: ^StageInputOutputDescriptor) -> IndexType { @@ -3853,7 +3902,7 @@ StageInputOutputDescriptor_reset :: #force_inline proc(self: ^StageInputOutputDe msgSend(nil, self, "reset") } @(objc_type=StageInputOutputDescriptor, objc_name="setIndexBufferIndex") -StageInputOutputDescriptor_setIndexBufferIndex :: #force_inline proc(self: ^StageInputOutputDescriptor, indexBufferIndex: NS.Integer) { +StageInputOutputDescriptor_setIndexBufferIndex :: #force_inline proc(self: ^StageInputOutputDescriptor, indexBufferIndex: NS.UInteger) { msgSend(nil, self, "setIndexBufferIndex:", indexBufferIndex) } @(objc_type=StageInputOutputDescriptor, objc_name="setIndexType") @@ -3977,8 +4026,8 @@ StructMember_init :: #force_inline proc(self: ^StructMember) -> ^StructMember { return msgSend(^StructMember, self, "init") } @(objc_type=StructMember, objc_name="argumentIndex") -StructMember_argumentIndex :: #force_inline proc(self: ^StructMember) -> NS.Integer { - return msgSend(NS.Integer, self, "argumentIndex") +StructMember_argumentIndex :: #force_inline proc(self: ^StructMember) -> NS.UInteger { + return msgSend(NS.UInteger, self, "argumentIndex") } @(objc_type=StructMember, objc_name="arrayType") StructMember_arrayType :: #force_inline proc(self: ^StructMember) -> ^ArrayType { @@ -3993,8 +4042,8 @@ StructMember_name :: #force_inline proc(self: ^StructMember) -> ^NS.String { return msgSend(^NS.String, self, "name") } @(objc_type=StructMember, objc_name="offset") -StructMember_offset :: #force_inline proc(self: ^StructMember) -> NS.Integer { - return msgSend(NS.Integer, self, "offset") +StructMember_offset :: #force_inline proc(self: ^StructMember) -> NS.UInteger { + return msgSend(NS.UInteger, self, "offset") } @(objc_type=StructMember, objc_name="pointerType") StructMember_pointerType :: #force_inline proc(self: ^StructMember) -> ^PointerType { @@ -4100,28 +4149,28 @@ TextureDescriptor_allowGPUOptimizedContents :: #force_inline proc(self: ^Texture return msgSend(BOOL, self, "allowGPUOptimizedContents") } @(objc_type=TextureDescriptor, objc_name="arrayLength") -TextureDescriptor_arrayLength :: #force_inline proc(self: ^TextureDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "arrayLength") +TextureDescriptor_arrayLength :: #force_inline proc(self: ^TextureDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "arrayLength") } @(objc_type=TextureDescriptor, objc_name="cpuCacheMode") TextureDescriptor_cpuCacheMode :: #force_inline proc(self: ^TextureDescriptor) -> CPUCacheMode { return msgSend(CPUCacheMode, self, "cpuCacheMode") } @(objc_type=TextureDescriptor, objc_name="depth") -TextureDescriptor_depth :: #force_inline proc(self: ^TextureDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "depth") +TextureDescriptor_depth :: #force_inline proc(self: ^TextureDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "depth") } @(objc_type=TextureDescriptor, objc_name="hazardTrackingMode") TextureDescriptor_hazardTrackingMode :: #force_inline proc(self: ^TextureDescriptor) -> HazardTrackingMode { return msgSend(HazardTrackingMode, self, "hazardTrackingMode") } @(objc_type=TextureDescriptor, objc_name="height") -TextureDescriptor_height :: #force_inline proc(self: ^TextureDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "height") +TextureDescriptor_height :: #force_inline proc(self: ^TextureDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "height") } @(objc_type=TextureDescriptor, objc_name="mipmapLevelCount") -TextureDescriptor_mipmapLevelCount :: #force_inline proc(self: ^TextureDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "mipmapLevelCount") +TextureDescriptor_mipmapLevelCount :: #force_inline proc(self: ^TextureDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "mipmapLevelCount") } @(objc_type=TextureDescriptor, objc_name="pixelFormat") TextureDescriptor_pixelFormat :: #force_inline proc(self: ^TextureDescriptor) -> PixelFormat { @@ -4132,15 +4181,15 @@ TextureDescriptor_resourceOptions :: #force_inline proc(self: ^TextureDescriptor return msgSend(ResourceOptions, self, "resourceOptions") } @(objc_type=TextureDescriptor, objc_name="sampleCount") -TextureDescriptor_sampleCount :: #force_inline proc(self: ^TextureDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "sampleCount") +TextureDescriptor_sampleCount :: #force_inline proc(self: ^TextureDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "sampleCount") } @(objc_type=TextureDescriptor, objc_name="setAllowGPUOptimizedContents") TextureDescriptor_setAllowGPUOptimizedContents :: #force_inline proc(self: ^TextureDescriptor, allowGPUOptimizedContents: BOOL) { msgSend(nil, self, "setAllowGPUOptimizedContents:", allowGPUOptimizedContents) } @(objc_type=TextureDescriptor, objc_name="setArrayLength") -TextureDescriptor_setArrayLength :: #force_inline proc(self: ^TextureDescriptor, arrayLength: NS.Integer) { +TextureDescriptor_setArrayLength :: #force_inline proc(self: ^TextureDescriptor, arrayLength: NS.UInteger) { msgSend(nil, self, "setArrayLength:", arrayLength) } @(objc_type=TextureDescriptor, objc_name="setCpuCacheMode") @@ -4148,7 +4197,7 @@ TextureDescriptor_setCpuCacheMode :: #force_inline proc(self: ^TextureDescriptor msgSend(nil, self, "setCpuCacheMode:", cpuCacheMode) } @(objc_type=TextureDescriptor, objc_name="setDepth") -TextureDescriptor_setDepth :: #force_inline proc(self: ^TextureDescriptor, depth: NS.Integer) { +TextureDescriptor_setDepth :: #force_inline proc(self: ^TextureDescriptor, depth: NS.UInteger) { msgSend(nil, self, "setDepth:", depth) } @(objc_type=TextureDescriptor, objc_name="setHazardTrackingMode") @@ -4156,11 +4205,11 @@ TextureDescriptor_setHazardTrackingMode :: #force_inline proc(self: ^TextureDesc msgSend(nil, self, "setHazardTrackingMode:", hazardTrackingMode) } @(objc_type=TextureDescriptor, objc_name="setHeight") -TextureDescriptor_setHeight :: #force_inline proc(self: ^TextureDescriptor, height: NS.Integer) { +TextureDescriptor_setHeight :: #force_inline proc(self: ^TextureDescriptor, height: NS.UInteger) { msgSend(nil, self, "setHeight:", height) } @(objc_type=TextureDescriptor, objc_name="setMipmapLevelCount") -TextureDescriptor_setMipmapLevelCount :: #force_inline proc(self: ^TextureDescriptor, mipmapLevelCount: NS.Integer) { +TextureDescriptor_setMipmapLevelCount :: #force_inline proc(self: ^TextureDescriptor, mipmapLevelCount: NS.UInteger) { msgSend(nil, self, "setMipmapLevelCount:", mipmapLevelCount) } @(objc_type=TextureDescriptor, objc_name="setPixelFormat") @@ -4172,7 +4221,7 @@ TextureDescriptor_setResourceOptions :: #force_inline proc(self: ^TextureDescrip msgSend(nil, self, "setResourceOptions:", resourceOptions) } @(objc_type=TextureDescriptor, objc_name="setSampleCount") -TextureDescriptor_setSampleCount :: #force_inline proc(self: ^TextureDescriptor, sampleCount: NS.Integer) { +TextureDescriptor_setSampleCount :: #force_inline proc(self: ^TextureDescriptor, sampleCount: NS.UInteger) { msgSend(nil, self, "setSampleCount:", sampleCount) } @(objc_type=TextureDescriptor, objc_name="setStorageMode") @@ -4192,7 +4241,7 @@ TextureDescriptor_setUsage :: #force_inline proc(self: ^TextureDescriptor, usage msgSend(nil, self, "setUsage:", usage) } @(objc_type=TextureDescriptor, objc_name="setWidth") -TextureDescriptor_setWidth :: #force_inline proc(self: ^TextureDescriptor, width: NS.Integer) { +TextureDescriptor_setWidth :: #force_inline proc(self: ^TextureDescriptor, width: NS.UInteger) { msgSend(nil, self, "setWidth:", width) } @(objc_type=TextureDescriptor, objc_name="storageMode") @@ -4204,15 +4253,15 @@ TextureDescriptor_swizzle :: #force_inline proc(self: ^TextureDescriptor) -> Tex return msgSend(TextureSwizzleChannels, self, "swizzle") } @(objc_type=TextureDescriptor, objc_class_name="texture2DDescriptorWithPixelFormat") -TextureDescriptor_texture2DDescriptorWithPixelFormat :: #force_inline proc(pixelFormat: PixelFormat, width: ^NS.Object, height: ^NS.Object, mipmapped: BOOL) -> ^TextureDescriptor { +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_class_name="textureBufferDescriptorWithPixelFormat") -TextureDescriptor_textureBufferDescriptorWithPixelFormat :: #force_inline proc(pixelFormat: PixelFormat, width: ^NS.Object, resourceOptions: ResourceOptions, usage: TextureUsage) -> ^TextureDescriptor { +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_class_name="textureCubeDescriptorWithPixelFormat") -TextureDescriptor_textureCubeDescriptorWithPixelFormat :: #force_inline proc(pixelFormat: PixelFormat, size: ^NS.Object, mipmapped: BOOL) -> ^TextureDescriptor { +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") @@ -4224,8 +4273,8 @@ TextureDescriptor_usage :: #force_inline proc(self: ^TextureDescriptor) -> Textu return msgSend(TextureUsage, self, "usage") } @(objc_type=TextureDescriptor, objc_name="width") -TextureDescriptor_width :: #force_inline proc(self: ^TextureDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "width") +TextureDescriptor_width :: #force_inline proc(self: ^TextureDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "width") } //////////////////////////////////////////////////////////////////////////////// @@ -4326,11 +4375,11 @@ TileRenderPipelineColorAttachmentDescriptorArray_init :: #force_inline proc(self return msgSend(^TileRenderPipelineColorAttachmentDescriptorArray, self, "init") } @(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -TileRenderPipelineColorAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^TileRenderPipelineColorAttachmentDescriptor { +TileRenderPipelineColorAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^TileRenderPipelineColorAttachmentDescriptor { return msgSend(^TileRenderPipelineColorAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_name="setObject") -TileRenderPipelineColorAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray, attachment: ^TileRenderPipelineColorAttachmentDescriptor, attachmentIndex: ^NS.Object) { +TileRenderPipelineColorAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray, attachment: ^TileRenderPipelineColorAttachmentDescriptor, attachmentIndex: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -4383,12 +4432,12 @@ TileRenderPipelineDescriptor_label :: #force_inline proc(self: ^TileRenderPipeli return msgSend(^NS.String, self, "label") } @(objc_type=TileRenderPipelineDescriptor, objc_name="maxTotalThreadsPerThreadgroup") -TileRenderPipelineDescriptor_maxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "maxTotalThreadsPerThreadgroup") +TileRenderPipelineDescriptor_maxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "maxTotalThreadsPerThreadgroup") } @(objc_type=TileRenderPipelineDescriptor, objc_name="rasterSampleCount") -TileRenderPipelineDescriptor_rasterSampleCount :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "rasterSampleCount") +TileRenderPipelineDescriptor_rasterSampleCount :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "rasterSampleCount") } @(objc_type=TileRenderPipelineDescriptor, objc_name="reset") TileRenderPipelineDescriptor_reset :: #force_inline proc(self: ^TileRenderPipelineDescriptor) { @@ -4403,11 +4452,11 @@ TileRenderPipelineDescriptor_setLabel :: #force_inline proc(self: ^TileRenderPip msgSend(nil, self, "setLabel:", label) } @(objc_type=TileRenderPipelineDescriptor, objc_name="setMaxTotalThreadsPerThreadgroup") -TileRenderPipelineDescriptor_setMaxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^TileRenderPipelineDescriptor, maxTotalThreadsPerThreadgroup: NS.Integer) { +TileRenderPipelineDescriptor_setMaxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^TileRenderPipelineDescriptor, maxTotalThreadsPerThreadgroup: NS.UInteger) { msgSend(nil, self, "setMaxTotalThreadsPerThreadgroup:", maxTotalThreadsPerThreadgroup) } @(objc_type=TileRenderPipelineDescriptor, objc_name="setRasterSampleCount") -TileRenderPipelineDescriptor_setRasterSampleCount :: #force_inline proc(self: ^TileRenderPipelineDescriptor, rasterSampleCount: NS.Integer) { +TileRenderPipelineDescriptor_setRasterSampleCount :: #force_inline proc(self: ^TileRenderPipelineDescriptor, rasterSampleCount: NS.UInteger) { msgSend(nil, self, "setRasterSampleCount:", rasterSampleCount) } @(objc_type=TileRenderPipelineDescriptor, objc_name="setThreadgroupSizeMatchesTileSize") @@ -4415,7 +4464,7 @@ TileRenderPipelineDescriptor_setThreadgroupSizeMatchesTileSize :: #force_inline msgSend(nil, self, "setThreadgroupSizeMatchesTileSize:", threadgroupSizeMatchesTileSize) } @(objc_type=TileRenderPipelineDescriptor, objc_name="setTileFunction") -TileRenderPipelineDescriptor_setTileFunction :: #force_inline proc(self: ^TileRenderPipelineDescriptor, tileFunction: ^NS.Object) { +TileRenderPipelineDescriptor_setTileFunction :: #force_inline proc(self: ^TileRenderPipelineDescriptor, tileFunction: ^Function) { msgSend(nil, self, "setTileFunction:", tileFunction) } @(objc_type=TileRenderPipelineDescriptor, objc_name="threadgroupSizeMatchesTileSize") @@ -4486,8 +4535,8 @@ VertexAttribute_init :: #force_inline proc(self: ^VertexAttribute) -> ^VertexAtt return msgSend(^VertexAttribute, self, "init") } @(objc_type=VertexAttribute, objc_name="attributeIndex") -VertexAttribute_attributeIndex :: #force_inline proc(self: ^VertexAttribute) -> NS.Integer { - return msgSend(NS.Integer, self, "attributeIndex") +VertexAttribute_attributeIndex :: #force_inline proc(self: ^VertexAttribute) -> NS.UInteger { + return msgSend(NS.UInteger, self, "attributeIndex") } @(objc_type=VertexAttribute, objc_name="attributeType") VertexAttribute_attributeType :: #force_inline proc(self: ^VertexAttribute) -> DataType { @@ -4538,19 +4587,19 @@ VertexAttributeDescriptor_init :: #force_inline proc(self: ^VertexAttributeDescr return msgSend(^VertexAttributeDescriptor, self, "init") } @(objc_type=VertexAttributeDescriptor, objc_name="bufferIndex") -VertexAttributeDescriptor_bufferIndex :: #force_inline proc(self: ^VertexAttributeDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "bufferIndex") +VertexAttributeDescriptor_bufferIndex :: #force_inline proc(self: ^VertexAttributeDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "bufferIndex") } @(objc_type=VertexAttributeDescriptor, objc_name="format") VertexAttributeDescriptor_format :: #force_inline proc(self: ^VertexAttributeDescriptor) -> VertexFormat { return msgSend(VertexFormat, self, "format") } @(objc_type=VertexAttributeDescriptor, objc_name="offset") -VertexAttributeDescriptor_offset :: #force_inline proc(self: ^VertexAttributeDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "offset") +VertexAttributeDescriptor_offset :: #force_inline proc(self: ^VertexAttributeDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "offset") } @(objc_type=VertexAttributeDescriptor, objc_name="setBufferIndex") -VertexAttributeDescriptor_setBufferIndex :: #force_inline proc(self: ^VertexAttributeDescriptor, bufferIndex: NS.Integer) { +VertexAttributeDescriptor_setBufferIndex :: #force_inline proc(self: ^VertexAttributeDescriptor, bufferIndex: NS.UInteger) { msgSend(nil, self, "setBufferIndex:", bufferIndex) } @(objc_type=VertexAttributeDescriptor, objc_name="setFormat") @@ -4558,7 +4607,7 @@ VertexAttributeDescriptor_setFormat :: #force_inline proc(self: ^VertexAttribute msgSend(nil, self, "setFormat:", format) } @(objc_type=VertexAttributeDescriptor, objc_name="setOffset") -VertexAttributeDescriptor_setOffset :: #force_inline proc(self: ^VertexAttributeDescriptor, offset: NS.Integer) { +VertexAttributeDescriptor_setOffset :: #force_inline proc(self: ^VertexAttributeDescriptor, offset: NS.UInteger) { msgSend(nil, self, "setOffset:", offset) } @@ -4586,11 +4635,11 @@ VertexAttributeDescriptorArray_init :: #force_inline proc(self: ^VertexAttribute return msgSend(^VertexAttributeDescriptorArray, self, "init") } @(objc_type=VertexAttributeDescriptorArray, objc_name="objectAtIndexedSubscript") -VertexAttributeDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^VertexAttributeDescriptorArray, index: ^NS.Object) -> ^VertexAttributeDescriptor { +VertexAttributeDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^VertexAttributeDescriptorArray, index: NS.UInteger) -> ^VertexAttributeDescriptor { return msgSend(^VertexAttributeDescriptor, self, "objectAtIndexedSubscript:", index) } @(objc_type=VertexAttributeDescriptorArray, objc_name="setObject") -VertexAttributeDescriptorArray_setObject :: #force_inline proc(self: ^VertexAttributeDescriptorArray, attributeDesc: ^VertexAttributeDescriptor, index: ^NS.Object) { +VertexAttributeDescriptorArray_setObject :: #force_inline proc(self: ^VertexAttributeDescriptorArray, attributeDesc: ^VertexAttributeDescriptor, index: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", attributeDesc, index) } @@ -4626,11 +4675,11 @@ VertexBufferLayoutDescriptor_setStepFunction :: #force_inline proc(self: ^Vertex msgSend(nil, self, "setStepFunction:", stepFunction) } @(objc_type=VertexBufferLayoutDescriptor, objc_name="setStepRate") -VertexBufferLayoutDescriptor_setStepRate :: #force_inline proc(self: ^VertexBufferLayoutDescriptor, stepRate: NS.Integer) { +VertexBufferLayoutDescriptor_setStepRate :: #force_inline proc(self: ^VertexBufferLayoutDescriptor, stepRate: NS.UInteger) { msgSend(nil, self, "setStepRate:", stepRate) } @(objc_type=VertexBufferLayoutDescriptor, objc_name="setStride") -VertexBufferLayoutDescriptor_setStride :: #force_inline proc(self: ^VertexBufferLayoutDescriptor, stride: NS.Integer) { +VertexBufferLayoutDescriptor_setStride :: #force_inline proc(self: ^VertexBufferLayoutDescriptor, stride: NS.UInteger) { msgSend(nil, self, "setStride:", stride) } @(objc_type=VertexBufferLayoutDescriptor, objc_name="stepFunction") @@ -4638,12 +4687,12 @@ VertexBufferLayoutDescriptor_stepFunction :: #force_inline proc(self: ^VertexBuf return msgSend(VertexStepFunction, self, "stepFunction") } @(objc_type=VertexBufferLayoutDescriptor, objc_name="stepRate") -VertexBufferLayoutDescriptor_stepRate :: #force_inline proc(self: ^VertexBufferLayoutDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "stepRate") +VertexBufferLayoutDescriptor_stepRate :: #force_inline proc(self: ^VertexBufferLayoutDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "stepRate") } @(objc_type=VertexBufferLayoutDescriptor, objc_name="stride") -VertexBufferLayoutDescriptor_stride :: #force_inline proc(self: ^VertexBufferLayoutDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "stride") +VertexBufferLayoutDescriptor_stride :: #force_inline proc(self: ^VertexBufferLayoutDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "stride") } //////////////////////////////////////////////////////////////////////////////// @@ -4670,11 +4719,11 @@ VertexBufferLayoutDescriptorArray_init :: #force_inline proc(self: ^VertexBuffer return msgSend(^VertexBufferLayoutDescriptorArray, self, "init") } @(objc_type=VertexBufferLayoutDescriptorArray, objc_name="objectAtIndexedSubscript") -VertexBufferLayoutDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^VertexBufferLayoutDescriptorArray, index: ^NS.Object) -> ^VertexBufferLayoutDescriptor { +VertexBufferLayoutDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^VertexBufferLayoutDescriptorArray, index: NS.UInteger) -> ^VertexBufferLayoutDescriptor { return msgSend(^VertexBufferLayoutDescriptor, self, "objectAtIndexedSubscript:", index) } @(objc_type=VertexBufferLayoutDescriptorArray, objc_name="setObject") -VertexBufferLayoutDescriptorArray_setObject :: #force_inline proc(self: ^VertexBufferLayoutDescriptorArray, bufferDesc: ^VertexBufferLayoutDescriptor, index: ^NS.Object) { +VertexBufferLayoutDescriptorArray_setObject :: #force_inline proc(self: ^VertexBufferLayoutDescriptorArray, bufferDesc: ^VertexBufferLayoutDescriptor, index: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", bufferDesc, index) } @@ -4745,11 +4794,11 @@ VisibleFunctionTableDescriptor_init :: #force_inline proc(self: ^VisibleFunction return msgSend(^VisibleFunctionTableDescriptor, self, "init") } @(objc_type=VisibleFunctionTableDescriptor, objc_name="functionCount") -VisibleFunctionTableDescriptor_functionCount :: #force_inline proc(self: ^VisibleFunctionTableDescriptor) -> NS.Integer { - return msgSend(NS.Integer, self, "functionCount") +VisibleFunctionTableDescriptor_functionCount :: #force_inline proc(self: ^VisibleFunctionTableDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "functionCount") } @(objc_type=VisibleFunctionTableDescriptor, objc_name="setFunctionCount") -VisibleFunctionTableDescriptor_setFunctionCount :: #force_inline proc(self: ^VisibleFunctionTableDescriptor, functionCount: NS.Integer) { +VisibleFunctionTableDescriptor_setFunctionCount :: #force_inline proc(self: ^VisibleFunctionTableDescriptor, functionCount: NS.UInteger) { msgSend(nil, self, "setFunctionCount:", functionCount) } @(objc_type=VisibleFunctionTableDescriptor, objc_class_name="visibleFunctionTableDescriptor") @@ -4767,11 +4816,11 @@ Methods: size */ @(objc_class="MTLAccelerationStructure") -AccelerationStructure :: struct { using _: NS.Object } +AccelerationStructure :: struct { using _: Resource } @(objc_type=AccelerationStructure, objc_name="size") -AccelerationStructure_size :: #force_inline proc(self: ^AccelerationStructure) -> NS.Integer { - return msgSend(NS.Integer, self, "size") +AccelerationStructure_size :: #force_inline proc(self: ^AccelerationStructure) -> NS.UInteger { + return msgSend(NS.UInteger, self, "size") } //////////////////////////////////////////////////////////////////////////////// @@ -4798,51 +4847,51 @@ Methods: AccelerationStructureCommandEncoder :: struct { using _: NS.Object } @(objc_type=AccelerationStructureCommandEncoder, objc_name="buildAccelerationStructure") -AccelerationStructureCommandEncoder_buildAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, accelerationStructure: ^NS.Object, descriptor: ^AccelerationStructureDescriptor, scratchBuffer: ^NS.Object, scratchBufferOffset: ^NS.Object) { +AccelerationStructureCommandEncoder_buildAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, accelerationStructure: ^AccelerationStructure, descriptor: ^AccelerationStructureDescriptor, scratchBuffer: ^Buffer, scratchBufferOffset: NS.UInteger) { msgSend(nil, self, "buildAccelerationStructure:descriptor:scratchBuffer:scratchBufferOffset:", accelerationStructure, descriptor, scratchBuffer, scratchBufferOffset) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="copyAccelerationStructure") -AccelerationStructureCommandEncoder_copyAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^NS.Object, destinationAccelerationStructure: ^NS.Object) { +AccelerationStructureCommandEncoder_copyAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^AccelerationStructure, destinationAccelerationStructure: ^AccelerationStructure) { msgSend(nil, self, "copyAccelerationStructure:toAccelerationStructure:", sourceAccelerationStructure, destinationAccelerationStructure) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="copyAndCompactAccelerationStructure") -AccelerationStructureCommandEncoder_copyAndCompactAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^NS.Object, destinationAccelerationStructure: ^NS.Object) { +AccelerationStructureCommandEncoder_copyAndCompactAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^AccelerationStructure, destinationAccelerationStructure: ^AccelerationStructure) { msgSend(nil, self, "copyAndCompactAccelerationStructure:toAccelerationStructure:", sourceAccelerationStructure, destinationAccelerationStructure) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="refitAccelerationStructure") -AccelerationStructureCommandEncoder_refitAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^NS.Object, descriptor: ^AccelerationStructureDescriptor, destinationAccelerationStructure: ^NS.Object, scratchBuffer: ^NS.Object, scratchBufferOffset: ^NS.Object) { +AccelerationStructureCommandEncoder_refitAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^AccelerationStructure, descriptor: ^AccelerationStructureDescriptor, destinationAccelerationStructure: ^AccelerationStructure, scratchBuffer: ^Buffer, scratchBufferOffset: NS.UInteger) { msgSend(nil, self, "refitAccelerationStructure:descriptor:destination:scratchBuffer:scratchBufferOffset:", sourceAccelerationStructure, descriptor, destinationAccelerationStructure, scratchBuffer, scratchBufferOffset) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="sampleCountersInBuffer") -AccelerationStructureCommandEncoder_sampleCountersInBuffer :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) { +AccelerationStructureCommandEncoder_sampleCountersInBuffer :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sampleBuffer: ^Buffer, sampleIndex: NS.UInteger, barrier: BOOL) { msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="updateFence") -AccelerationStructureCommandEncoder_updateFence :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, fence: ^NS.Object) { +AccelerationStructureCommandEncoder_updateFence :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, fence: ^Fence) { msgSend(nil, self, "updateFence:", fence) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="useHeap") -AccelerationStructureCommandEncoder_useHeap :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, heap: ^NS.Object) { +AccelerationStructureCommandEncoder_useHeap :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, heap: ^Heap) { msgSend(nil, self, "useHeap:", heap) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="useHeaps") -AccelerationStructureCommandEncoder_useHeaps :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object) { +AccelerationStructureCommandEncoder_useHeaps :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, heaps: [^]^Heap, count: NS.UInteger) { msgSend(nil, self, "useHeaps:count:", heaps, count) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="useResource") -AccelerationStructureCommandEncoder_useResource :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, resource: ^NS.Object, usage: ResourceUsage) { +AccelerationStructureCommandEncoder_useResource :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, resource: ^Resource, usage: ResourceUsage) { msgSend(nil, self, "useResource:usage:", resource, usage) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="useResources") -AccelerationStructureCommandEncoder_useResources :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage) { +AccelerationStructureCommandEncoder_useResources :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, resources: [^]^Resource, count: NS.UInteger, usage: ResourceUsage) { msgSend(nil, self, "useResources:count:usage:", resources, count, usage) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="waitForFence") -AccelerationStructureCommandEncoder_waitForFence :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, fence: ^NS.Object) { +AccelerationStructureCommandEncoder_waitForFence :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, fence: ^Fence) { msgSend(nil, self, "waitForFence:", fence) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="writeCompactedAccelerationStructureSize") -AccelerationStructureCommandEncoder_writeCompactedAccelerationStructureSize :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, accelerationStructure: ^NS.Object, buffer: ^NS.Object, offset: ^NS.Object) { +AccelerationStructureCommandEncoder_writeCompactedAccelerationStructureSize :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, accelerationStructure: ^AccelerationStructure, buffer: ^Buffer, offset: NS.UInteger) { msgSend(nil, self, "writeCompactedAccelerationStructureSize:toBuffer:offset:", accelerationStructure, buffer, offset) } @@ -4884,11 +4933,11 @@ Methods: ArgumentEncoder :: struct { using _: NS.Object } @(objc_type=ArgumentEncoder, objc_name="alignment") -ArgumentEncoder_alignment :: #force_inline proc(self: ^ArgumentEncoder) -> NS.Integer { - return msgSend(NS.Integer, self, "alignment") +ArgumentEncoder_alignment :: #force_inline proc(self: ^ArgumentEncoder) -> NS.UInteger { + return msgSend(NS.UInteger, self, "alignment") } @(objc_type=ArgumentEncoder, objc_name="constantDataAtIndex") -ArgumentEncoder_constantDataAtIndex :: #force_inline proc(self: ^ArgumentEncoder, index: ^NS.Object) -> rawptr { +ArgumentEncoder_constantDataAtIndex :: #force_inline proc(self: ^ArgumentEncoder, index: NS.UInteger) -> rawptr { return msgSend(rawptr, self, "constantDataAtIndex:", index) } @(objc_type=ArgumentEncoder, objc_name="device") @@ -4896,59 +4945,59 @@ ArgumentEncoder_device :: #force_inline proc(self: ^ArgumentEncoder) -> ^Argumen return msgSend(^ArgumentEncoder, self, "device") } @(objc_type=ArgumentEncoder, objc_name="encodedLength") -ArgumentEncoder_encodedLength :: #force_inline proc(self: ^ArgumentEncoder) -> NS.Integer { - return msgSend(NS.Integer, self, "encodedLength") +ArgumentEncoder_encodedLength :: #force_inline proc(self: ^ArgumentEncoder) -> NS.UInteger { + return msgSend(NS.UInteger, self, "encodedLength") } @(objc_type=ArgumentEncoder, objc_name="label") ArgumentEncoder_label :: #force_inline proc(self: ^ArgumentEncoder) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=ArgumentEncoder, objc_name="newArgumentEncoderForBufferAtIndex") -ArgumentEncoder_newArgumentEncoderForBufferAtIndex :: #force_inline proc(self: ^ArgumentEncoder, index: ^NS.Object) -> ^ArgumentEncoder { +ArgumentEncoder_newArgumentEncoderForBufferAtIndex :: #force_inline proc(self: ^ArgumentEncoder, index: NS.UInteger) -> ^ArgumentEncoder { return msgSend(^ArgumentEncoder, self, "newArgumentEncoderForBufferAtIndex:", index) } @(objc_type=ArgumentEncoder, objc_name="setAccelerationStructure") -ArgumentEncoder_setAccelerationStructure :: #force_inline proc(self: ^ArgumentEncoder, accelerationStructure: ^NS.Object, index: ^NS.Object) { +ArgumentEncoder_setAccelerationStructure :: #force_inline proc(self: ^ArgumentEncoder, accelerationStructure: ^AccelerationStructure, index: NS.UInteger) { msgSend(nil, self, "setAccelerationStructure:atIndex:", accelerationStructure, index) } -@(objc_type=ArgumentEncoder, objc_name="setArgumentBuffer_offset_") -ArgumentEncoder_setArgumentBuffer_offset_ :: #force_inline proc(self: ^ArgumentEncoder, argumentBuffer: ^NS.Object, offset: ^NS.Object) { +@(objc_type=ArgumentEncoder, objc_name="setArgumentBufferWithOffset") +ArgumentEncoder_setArgumentBufferWithOffset :: #force_inline proc(self: ^ArgumentEncoder, argumentBuffer: ^Buffer, offset: NS.UInteger) { msgSend(nil, self, "setArgumentBuffer:offset:", argumentBuffer, offset) } -@(objc_type=ArgumentEncoder, objc_name="setArgumentBuffer_startOffset_arrayElement_") -ArgumentEncoder_setArgumentBuffer_startOffset_arrayElement_ :: #force_inline proc(self: ^ArgumentEncoder, argumentBuffer: ^NS.Object, startOffset: ^NS.Object, arrayElement: ^NS.Object) { +@(objc_type=ArgumentEncoder, objc_name="setArgumentBuffer_startOffsetWithStartOffset") +ArgumentEncoder_setArgumentBuffer_startOffsetWithStartOffset :: #force_inline proc(self: ^ArgumentEncoder, argumentBuffer: ^Buffer, startOffset: NS.UInteger, arrayElement: NS.UInteger) { msgSend(nil, self, "setArgumentBuffer:startOffset:arrayElement:", argumentBuffer, startOffset, arrayElement) } @(objc_type=ArgumentEncoder, objc_name="setBuffer") -ArgumentEncoder_setBuffer :: #force_inline proc(self: ^ArgumentEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +ArgumentEncoder_setBuffer :: #force_inline proc(self: ^ArgumentEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=ArgumentEncoder, objc_name="setBuffers") -ArgumentEncoder_setBuffers :: #force_inline proc(self: ^ArgumentEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { +ArgumentEncoder_setBuffers :: #force_inline proc(self: ^ArgumentEncoder, buffers: [^]^Buffer, offsets: [^]NS.UInteger, range: NS.Range) { msgSend(nil, self, "setBuffers:offsets:withRange:", buffers, offsets, range) } @(objc_type=ArgumentEncoder, objc_name="setComputePipelineState") -ArgumentEncoder_setComputePipelineState :: #force_inline proc(self: ^ArgumentEncoder, pipeline: ^NS.Object, index: ^NS.Object) { +ArgumentEncoder_setComputePipelineState :: #force_inline proc(self: ^ArgumentEncoder, pipeline: ^ComputePipelineState, index: NS.UInteger) { msgSend(nil, self, "setComputePipelineState:atIndex:", pipeline, index) } @(objc_type=ArgumentEncoder, objc_name="setComputePipelineStates") -ArgumentEncoder_setComputePipelineStates :: #force_inline proc(self: ^ArgumentEncoder, pipelines: ^^NS.Object, range: NS.Range) { +ArgumentEncoder_setComputePipelineStates :: #force_inline proc(self: ^ArgumentEncoder, pipelines: [^]^ComputePipelineState, range: NS.Range) { msgSend(nil, self, "setComputePipelineStates:withRange:", pipelines, range) } @(objc_type=ArgumentEncoder, objc_name="setIndirectCommandBuffer") -ArgumentEncoder_setIndirectCommandBuffer :: #force_inline proc(self: ^ArgumentEncoder, indirectCommandBuffer: ^NS.Object, index: ^NS.Object) { +ArgumentEncoder_setIndirectCommandBuffer :: #force_inline proc(self: ^ArgumentEncoder, indirectCommandBuffer: ^Buffer, index: NS.UInteger) { msgSend(nil, self, "setIndirectCommandBuffer:atIndex:", indirectCommandBuffer, index) } @(objc_type=ArgumentEncoder, objc_name="setIndirectCommandBuffers") -ArgumentEncoder_setIndirectCommandBuffers :: #force_inline proc(self: ^ArgumentEncoder, buffers: ^^NS.Object, range: NS.Range) { +ArgumentEncoder_setIndirectCommandBuffers :: #force_inline proc(self: ^ArgumentEncoder, buffers: [^]^Buffer, range: NS.Range) { msgSend(nil, self, "setIndirectCommandBuffers:withRange:", buffers, range) } @(objc_type=ArgumentEncoder, objc_name="setIntersectionFunctionTable") -ArgumentEncoder_setIntersectionFunctionTable :: #force_inline proc(self: ^ArgumentEncoder, intersectionFunctionTable: ^NS.Object, index: ^NS.Object) { +ArgumentEncoder_setIntersectionFunctionTable :: #force_inline proc(self: ^ArgumentEncoder, intersectionFunctionTable: ^IntersectionFunctionTable, index: NS.UInteger) { msgSend(nil, self, "setIntersectionFunctionTable:atIndex:", intersectionFunctionTable, index) } @(objc_type=ArgumentEncoder, objc_name="setIntersectionFunctionTables") -ArgumentEncoder_setIntersectionFunctionTables :: #force_inline proc(self: ^ArgumentEncoder, intersectionFunctionTables: ^^NS.Object, range: NS.Range) { +ArgumentEncoder_setIntersectionFunctionTables :: #force_inline proc(self: ^ArgumentEncoder, intersectionFunctionTables: [^]^IntersectionFunctionTable, range: NS.Range) { msgSend(nil, self, "setIntersectionFunctionTables:withRange:", intersectionFunctionTables, range) } @(objc_type=ArgumentEncoder, objc_name="setLabel") @@ -4956,35 +5005,35 @@ ArgumentEncoder_setLabel :: #force_inline proc(self: ^ArgumentEncoder, label: ^N msgSend(nil, self, "setLabel:", label) } @(objc_type=ArgumentEncoder, objc_name="setRenderPipelineState") -ArgumentEncoder_setRenderPipelineState :: #force_inline proc(self: ^ArgumentEncoder, pipeline: ^NS.Object, index: ^NS.Object) { +ArgumentEncoder_setRenderPipelineState :: #force_inline proc(self: ^ArgumentEncoder, pipeline: ^RenderPipelineState, index: NS.UInteger) { msgSend(nil, self, "setRenderPipelineState:atIndex:", pipeline, index) } @(objc_type=ArgumentEncoder, objc_name="setRenderPipelineStates") -ArgumentEncoder_setRenderPipelineStates :: #force_inline proc(self: ^ArgumentEncoder, pipelines: ^^NS.Object, range: NS.Range) { +ArgumentEncoder_setRenderPipelineStates :: #force_inline proc(self: ^ArgumentEncoder, pipelines: [^]^RenderPipelineState, range: NS.Range) { msgSend(nil, self, "setRenderPipelineStates:withRange:", pipelines, range) } @(objc_type=ArgumentEncoder, objc_name="setSamplerState") -ArgumentEncoder_setSamplerState :: #force_inline proc(self: ^ArgumentEncoder, sampler: ^NS.Object, index: ^NS.Object) { +ArgumentEncoder_setSamplerState :: #force_inline proc(self: ^ArgumentEncoder, sampler: ^SamplerState, index: NS.UInteger) { msgSend(nil, self, "setSamplerState:atIndex:", sampler, index) } @(objc_type=ArgumentEncoder, objc_name="setSamplerStates") -ArgumentEncoder_setSamplerStates :: #force_inline proc(self: ^ArgumentEncoder, samplers: ^^NS.Object, range: NS.Range) { +ArgumentEncoder_setSamplerStates :: #force_inline proc(self: ^ArgumentEncoder, samplers: [^]^SamplerState, range: NS.Range) { msgSend(nil, self, "setSamplerStates:withRange:", samplers, range) } @(objc_type=ArgumentEncoder, objc_name="setTexture") -ArgumentEncoder_setTexture :: #force_inline proc(self: ^ArgumentEncoder, texture: ^NS.Object, index: ^NS.Object) { +ArgumentEncoder_setTexture :: #force_inline proc(self: ^ArgumentEncoder, texture: ^Texture, index: NS.UInteger) { msgSend(nil, self, "setTexture:atIndex:", texture, index) } @(objc_type=ArgumentEncoder, objc_name="setTextures") -ArgumentEncoder_setTextures :: #force_inline proc(self: ^ArgumentEncoder, textures: ^^NS.Object, range: NS.Range) { +ArgumentEncoder_setTextures :: #force_inline proc(self: ^ArgumentEncoder, textures: [^]^Texture, range: NS.Range) { msgSend(nil, self, "setTextures:withRange:", textures, range) } @(objc_type=ArgumentEncoder, objc_name="setVisibleFunctionTable") -ArgumentEncoder_setVisibleFunctionTable :: #force_inline proc(self: ^ArgumentEncoder, visibleFunctionTable: ^NS.Object, index: ^NS.Object) { +ArgumentEncoder_setVisibleFunctionTable :: #force_inline proc(self: ^ArgumentEncoder, visibleFunctionTable: ^VisibleFunctionTable, index: NS.UInteger) { msgSend(nil, self, "setVisibleFunctionTable:atIndex:", visibleFunctionTable, index) } @(objc_type=ArgumentEncoder, objc_name="setVisibleFunctionTables") -ArgumentEncoder_setVisibleFunctionTables :: #force_inline proc(self: ^ArgumentEncoder, visibleFunctionTables: ^^NS.Object, range: NS.Range) { +ArgumentEncoder_setVisibleFunctionTables :: #force_inline proc(self: ^ArgumentEncoder, visibleFunctionTables: [^]^VisibleFunctionTable, range: NS.Range) { msgSend(nil, self, "setVisibleFunctionTables:withRange:", visibleFunctionTables, range) } @@ -5007,16 +5056,19 @@ Methods: BinaryArchive :: struct { using _: NS.Copying(BinaryArchive) } @(objc_type=BinaryArchive, objc_name="addComputePipelineFunctionsWithDescriptor") -BinaryArchive_addComputePipelineFunctionsWithDescriptor :: #force_inline proc(self: ^BinaryArchive, descriptor: ^ComputePipelineDescriptor, error: ^^NS.Error ) -> BOOL { - return msgSend(BOOL, self, "addComputePipelineFunctionsWithDescriptor:error:", descriptor, error) +BinaryArchive_addComputePipelineFunctionsWithDescriptor :: #force_inline proc(self: ^BinaryArchive, descriptor: ^ComputePipelineDescriptor) -> (ok: bool, error: ^NS.Error) { + ok = msgSend(BOOL, self, "addComputePipelineFunctionsWithDescriptor:error:", descriptor, &error) + return } @(objc_type=BinaryArchive, objc_name="addRenderPipelineFunctionsWithDescriptor") -BinaryArchive_addRenderPipelineFunctionsWithDescriptor :: #force_inline proc(self: ^BinaryArchive, descriptor: ^RenderPipelineDescriptor, error: ^^NS.Error ) -> BOOL { - return msgSend(BOOL, self, "addRenderPipelineFunctionsWithDescriptor:error:", descriptor, error) +BinaryArchive_addRenderPipelineFunctionsWithDescriptor :: #force_inline proc(self: ^BinaryArchive, descriptor: ^RenderPipelineDescriptor) -> (ok: bool, error: ^NS.Error) { + ok = msgSend(BOOL, self, "addRenderPipelineFunctionsWithDescriptor:error:", descriptor, &error) + return } @(objc_type=BinaryArchive, objc_name="addTileRenderPipelineFunctionsWithDescriptor") -BinaryArchive_addTileRenderPipelineFunctionsWithDescriptor :: #force_inline proc(self: ^BinaryArchive, descriptor: ^TileRenderPipelineDescriptor, error: ^^NS.Error ) -> BOOL { - return msgSend(BOOL, self, "addTileRenderPipelineFunctionsWithDescriptor:error:", descriptor, error) +BinaryArchive_addTileRenderPipelineFunctionsWithDescriptor :: #force_inline proc(self: ^BinaryArchive, descriptor: ^TileRenderPipelineDescriptor) -> (ok: bool, error: ^NS.Error) { + ok = msgSend(BOOL, self, "addTileRenderPipelineFunctionsWithDescriptor:error:", descriptor, &error) + return } @(objc_type=BinaryArchive, objc_name="device") BinaryArchive_device :: #force_inline proc(self: ^BinaryArchive) -> ^BinaryArchive { @@ -5027,8 +5079,9 @@ BinaryArchive_label :: #force_inline proc(self: ^BinaryArchive) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=BinaryArchive, objc_name="serializeToURL") -BinaryArchive_serializeToURL :: #force_inline proc(self: ^BinaryArchive, url: ^NS.URL, error: ^^NS.Error ) -> BOOL { - return msgSend(BOOL, self, "serializeToURL:error:", url, error) +BinaryArchive_serializeToURL :: #force_inline proc(self: ^BinaryArchive, url: ^NS.URL) -> (ok: bool, error: ^NS.Error) { + ok = msgSend(BOOL, self, "serializeToURL:error:", url, &error) + return } @(objc_type=BinaryArchive, objc_name="setLabel") BinaryArchive_setLabel :: #force_inline proc(self: ^BinaryArchive, label: ^NS.String) { @@ -5072,103 +5125,103 @@ Methods: BlitCommandEncoder :: struct { using _: NS.Object } @(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_") -BlitCommandEncoder_copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^NS.Object, sourceOffset: ^NS.Object, sourceBytesPerRow: ^NS.Object, sourceBytesPerImage: ^NS.Object, sourceSize: Size, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, destinationOrigin: Origin) { +BlitCommandEncoder_copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^Buffer, sourceOffset: NS.UInteger, sourceBytesPerRow: NS.UInteger, sourceBytesPerImage: NS.UInteger, sourceSize: Size, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, destinationOrigin: Origin) { msgSend(nil, self, "copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:", sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin) } @(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_") -BlitCommandEncoder_copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^NS.Object, sourceOffset: ^NS.Object, sourceBytesPerRow: ^NS.Object, sourceBytesPerImage: ^NS.Object, sourceSize: Size, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, destinationOrigin: Origin, options: BlitOption) { +BlitCommandEncoder_copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^Buffer, sourceOffset: NS.UInteger, sourceBytesPerRow: NS.UInteger, sourceBytesPerImage: NS.UInteger, sourceSize: Size, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, destinationOrigin: Origin, options: BlitOption) { msgSend(nil, self, "copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:options:", sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin, options) } @(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_") -BlitCommandEncoder_copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^NS.Object, sourceOffset: ^NS.Object, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object, size: ^NS.Object) { +BlitCommandEncoder_copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^Buffer, sourceOffset: NS.UInteger, destinationBuffer: ^Buffer, destinationOffset: NS.UInteger, size: NS.UInteger) { msgSend(nil, self, "copyFromBuffer:sourceOffset:toBuffer:destinationOffset:size:", sourceBuffer, sourceOffset, destinationBuffer, destinationOffset, size) } @(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_") -BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object, destinationBytesPerRow: ^NS.Object, destinationBytesPerImage: ^NS.Object) { +BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^Buffer, destinationOffset: NS.UInteger, destinationBytesPerRow: NS.UInteger, destinationBytesPerImage: NS.UInteger) { msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:", sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage) } @(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_") -BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object, destinationBytesPerRow: ^NS.Object, destinationBytesPerImage: ^NS.Object, options: BlitOption) { +BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^Buffer, destinationOffset: NS.UInteger, destinationBytesPerRow: NS.UInteger, destinationBytesPerImage: NS.UInteger, options: BlitOption) { msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:options:", sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage, options) } @(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_") -BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, sourceOrigin: Origin, sourceSize: Size, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, destinationOrigin: Origin) { +BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, sourceOrigin: Origin, sourceSize: Size, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, destinationOrigin: Origin) { msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:", sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin) } @(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_") -BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, sliceCount: ^NS.Object, levelCount: ^NS.Object) { +BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, sliceCount: NS.UInteger, levelCount: NS.UInteger) { msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:toTexture:destinationSlice:destinationLevel:sliceCount:levelCount:", sourceTexture, sourceSlice, sourceLevel, destinationTexture, destinationSlice, destinationLevel, sliceCount, levelCount) } -@(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_toTexture_") -BlitCommandEncoder_copyFromTexture_toTexture_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, destinationTexture: ^NS.Object) { +@(objc_type=BlitCommandEncoder, objc_name="copyFromTexture") +BlitCommandEncoder_copyFromTexture :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^Texture, destinationTexture: ^Texture) { msgSend(nil, self, "copyFromTexture:toTexture:", sourceTexture, destinationTexture) } @(objc_type=BlitCommandEncoder, objc_name="copyIndirectCommandBuffer") -BlitCommandEncoder_copyIndirectCommandBuffer :: #force_inline proc(self: ^BlitCommandEncoder, source: ^NS.Object, sourceRange: NS.Range, destination: ^NS.Object, destinationIndex: ^NS.Object) { +BlitCommandEncoder_copyIndirectCommandBuffer :: #force_inline proc(self: ^BlitCommandEncoder, source: ^IndirectCommandBuffer, sourceRange: NS.Range, destination: ^IndirectCommandBuffer, destinationIndex: NS.UInteger) { msgSend(nil, self, "copyIndirectCommandBuffer:sourceRange:destination:destinationIndex:", source, sourceRange, destination, destinationIndex) } @(objc_type=BlitCommandEncoder, objc_name="fillBuffer") -BlitCommandEncoder_fillBuffer :: #force_inline proc(self: ^BlitCommandEncoder, buffer: ^NS.Object, range: NS.Range, value: u8) { +BlitCommandEncoder_fillBuffer :: #force_inline proc(self: ^BlitCommandEncoder, buffer: ^Buffer, range: NS.Range, value: u8) { msgSend(nil, self, "fillBuffer:range:value:", buffer, range, value) } @(objc_type=BlitCommandEncoder, objc_name="generateMipmapsForTexture") -BlitCommandEncoder_generateMipmapsForTexture :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^NS.Object) { +BlitCommandEncoder_generateMipmapsForTexture :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^Texture) { msgSend(nil, self, "generateMipmapsForTexture:", texture) } @(objc_type=BlitCommandEncoder, objc_name="getTextureAccessCounters") -BlitCommandEncoder_getTextureAccessCounters :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^NS.Object, region: Region, mipLevel: ^NS.Object, slice: ^NS.Object, resetCounters: BOOL, countersBuffer: ^NS.Object, countersBufferOffset: ^NS.Object) { +BlitCommandEncoder_getTextureAccessCounters :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^Texture, region: Region, mipLevel: NS.UInteger, slice: NS.UInteger, resetCounters: BOOL, countersBuffer: ^Buffer, countersBufferOffset: NS.UInteger) { msgSend(nil, self, "getTextureAccessCounters:region:mipLevel:slice:resetCounters:countersBuffer:countersBufferOffset:", texture, region, mipLevel, slice, resetCounters, countersBuffer, countersBufferOffset) } @(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForCPUAccess") -BlitCommandEncoder_optimizeContentsForCPUAccess :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^NS.Object) { +BlitCommandEncoder_optimizeContentsForCPUAccess :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^Texture) { msgSend(nil, self, "optimizeContentsForCPUAccess:", texture) } -@(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForCPUAccess_slice_level_") -BlitCommandEncoder_optimizeContentsForCPUAccess_slice_level_ :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^NS.Object, slice: ^NS.Object, level: ^NS.Object) { +@(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForCPUAccessWithSliceAndLevel") +BlitCommandEncoder_optimizeContentsForCPUAccessWithSliceAndLevel :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^Texture, slice: NS.UInteger, level: NS.UInteger) { msgSend(nil, self, "optimizeContentsForCPUAccess:slice:level:", texture, slice, level) } @(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForGPUAccess") -BlitCommandEncoder_optimizeContentsForGPUAccess :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^NS.Object) { +BlitCommandEncoder_optimizeContentsForGPUAccess :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^Texture) { msgSend(nil, self, "optimizeContentsForGPUAccess:", texture) } -@(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForGPUAccess_slice_level_") -BlitCommandEncoder_optimizeContentsForGPUAccess_slice_level_ :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^NS.Object, slice: ^NS.Object, level: ^NS.Object) { +@(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForGPUAccessWithSliceAndLevel") +BlitCommandEncoder_optimizeContentsForGPUAccessWithSliceAndLevel :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^Texture, slice: NS.UInteger, level: NS.UInteger) { msgSend(nil, self, "optimizeContentsForGPUAccess:slice:level:", texture, slice, level) } @(objc_type=BlitCommandEncoder, objc_name="optimizeIndirectCommandBuffer") -BlitCommandEncoder_optimizeIndirectCommandBuffer :: #force_inline proc(self: ^BlitCommandEncoder, indirectCommandBuffer: ^NS.Object, range: NS.Range) { +BlitCommandEncoder_optimizeIndirectCommandBuffer :: #force_inline proc(self: ^BlitCommandEncoder, indirectCommandBuffer: ^Buffer, range: NS.Range) { msgSend(nil, self, "optimizeIndirectCommandBuffer:withRange:", indirectCommandBuffer, range) } @(objc_type=BlitCommandEncoder, objc_name="resetCommandsInBuffer") -BlitCommandEncoder_resetCommandsInBuffer :: #force_inline proc(self: ^BlitCommandEncoder, buffer: ^NS.Object, range: NS.Range) { +BlitCommandEncoder_resetCommandsInBuffer :: #force_inline proc(self: ^BlitCommandEncoder, buffer: ^Buffer, range: NS.Range) { msgSend(nil, self, "resetCommandsInBuffer:withRange:", buffer, range) } @(objc_type=BlitCommandEncoder, objc_name="resetTextureAccessCounters") -BlitCommandEncoder_resetTextureAccessCounters :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^NS.Object, region: Region, mipLevel: ^NS.Object, slice: ^NS.Object) { +BlitCommandEncoder_resetTextureAccessCounters :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^Texture, region: Region, mipLevel: NS.UInteger, slice: NS.UInteger) { msgSend(nil, self, "resetTextureAccessCounters:region:mipLevel:slice:", texture, region, mipLevel, slice) } @(objc_type=BlitCommandEncoder, objc_name="resolveCounters") -BlitCommandEncoder_resolveCounters :: #force_inline proc(self: ^BlitCommandEncoder, sampleBuffer: ^NS.Object, range: NS.Range, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object) { +BlitCommandEncoder_resolveCounters :: #force_inline proc(self: ^BlitCommandEncoder, sampleBuffer: ^Buffer, range: NS.Range, destinationBuffer: ^Buffer, destinationOffset: NS.UInteger) { msgSend(nil, self, "resolveCounters:inRange:destinationBuffer:destinationOffset:", sampleBuffer, range, destinationBuffer, destinationOffset) } @(objc_type=BlitCommandEncoder, objc_name="sampleCountersInBuffer") -BlitCommandEncoder_sampleCountersInBuffer :: #force_inline proc(self: ^BlitCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) { +BlitCommandEncoder_sampleCountersInBuffer :: #force_inline proc(self: ^BlitCommandEncoder, sampleBuffer: ^Buffer, sampleIndex: NS.UInteger, barrier: BOOL) { msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier) } @(objc_type=BlitCommandEncoder, objc_name="synchronizeResource") -BlitCommandEncoder_synchronizeResource :: #force_inline proc(self: ^BlitCommandEncoder, resource: ^NS.Object) { +BlitCommandEncoder_synchronizeResource :: #force_inline proc(self: ^BlitCommandEncoder, resource: ^Resource) { msgSend(nil, self, "synchronizeResource:", resource) } @(objc_type=BlitCommandEncoder, objc_name="synchronizeTexture") -BlitCommandEncoder_synchronizeTexture :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^NS.Object, slice: ^NS.Object, level: ^NS.Object) { +BlitCommandEncoder_synchronizeTexture :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^Texture, slice: NS.UInteger, level: NS.UInteger) { msgSend(nil, self, "synchronizeTexture:slice:level:", texture, slice, level) } @(objc_type=BlitCommandEncoder, objc_name="updateFence") -BlitCommandEncoder_updateFence :: #force_inline proc(self: ^BlitCommandEncoder, fence: ^NS.Object) { +BlitCommandEncoder_updateFence :: #force_inline proc(self: ^BlitCommandEncoder, fence: ^Fence) { msgSend(nil, self, "updateFence:", fence) } @(objc_type=BlitCommandEncoder, objc_name="waitForFence") -BlitCommandEncoder_waitForFence :: #force_inline proc(self: ^BlitCommandEncoder, fence: ^NS.Object) { +BlitCommandEncoder_waitForFence :: #force_inline proc(self: ^BlitCommandEncoder, fence: ^Fence) { msgSend(nil, self, "waitForFence:", fence) } @@ -5189,7 +5242,7 @@ Methods: removeAllDebugMarkers */ @(objc_class="MTLBuffer") -Buffer :: struct { using _: NS.Object } +Buffer :: struct { using _: Resource } @(objc_type=Buffer, objc_name="addDebugMarker") Buffer_addDebugMarker :: #force_inline proc(self: ^Buffer, marker: ^NS.String, range: NS.Range) { @@ -5204,15 +5257,15 @@ Buffer_didModifyRange :: #force_inline proc(self: ^Buffer, range: NS.Range) { msgSend(nil, self, "didModifyRange:", range) } @(objc_type=Buffer, objc_name="length") -Buffer_length :: #force_inline proc(self: ^Buffer) -> NS.Integer { - return msgSend(NS.Integer, self, "length") +Buffer_length :: #force_inline proc(self: ^Buffer) -> NS.UInteger { + return msgSend(NS.UInteger, self, "length") } @(objc_type=Buffer, objc_name="newRemoteBufferViewForDevice") -Buffer_newRemoteBufferViewForDevice :: #force_inline proc(self: ^Buffer, device: ^NS.Object) -> ^Buffer { +Buffer_newRemoteBufferViewForDevice :: #force_inline proc(self: ^Buffer, device: ^Device) -> ^Buffer { return msgSend(^Buffer, self, "newRemoteBufferViewForDevice:", device) } @(objc_type=Buffer, objc_name="newTextureWithDescriptor") -Buffer_newTextureWithDescriptor :: #force_inline proc(self: ^Buffer, descriptor: ^TextureDescriptor, offset: ^NS.Object, bytesPerRow: ^NS.Object) -> ^Buffer { +Buffer_newTextureWithDescriptor :: #force_inline proc(self: ^Buffer, descriptor: ^TextureDescriptor, offset: NS.UInteger, bytesPerRow: NS.UInteger) -> ^Buffer { return msgSend(^Buffer, self, "newTextureWithDescriptor:offset:bytesPerRow:", descriptor, offset, bytesPerRow) } @(objc_type=Buffer, objc_name="remoteStorageBuffer") @@ -5366,11 +5419,11 @@ CommandBuffer_device :: #force_inline proc(self: ^CommandBuffer) -> ^CommandBuff return msgSend(^CommandBuffer, self, "device") } @(objc_type=CommandBuffer, objc_name="encodeSignalEvent") -CommandBuffer_encodeSignalEvent :: #force_inline proc(self: ^CommandBuffer, event: ^NS.Object, value: u64) { +CommandBuffer_encodeSignalEvent :: #force_inline proc(self: ^CommandBuffer, event: ^Event, value: u64) { msgSend(nil, self, "encodeSignalEvent:value:", event, value) } @(objc_type=CommandBuffer, objc_name="encodeWaitForEvent") -CommandBuffer_encodeWaitForEvent :: #force_inline proc(self: ^CommandBuffer, event: ^NS.Object, value: u64) { +CommandBuffer_encodeWaitForEvent :: #force_inline proc(self: ^CommandBuffer, event: ^Event, value: u64) { msgSend(nil, self, "encodeWaitForEvent:value:", event, value) } @(objc_type=CommandBuffer, objc_name="enqueue") @@ -5410,15 +5463,15 @@ CommandBuffer_popDebugGroup :: #force_inline proc(self: ^CommandBuffer) { msgSend(nil, self, "popDebugGroup") } @(objc_type=CommandBuffer, objc_name="presentDrawable") -CommandBuffer_presentDrawable :: #force_inline proc(self: ^CommandBuffer, drawable: ^NS.Object) { +CommandBuffer_presentDrawable :: #force_inline proc(self: ^CommandBuffer, drawable: ^Drawable) { msgSend(nil, self, "presentDrawable:", drawable) } -@(objc_type=CommandBuffer, objc_name="presentDrawable_afterMinimumDuration_") -CommandBuffer_presentDrawable_afterMinimumDuration_ :: #force_inline proc(self: ^CommandBuffer, drawable: ^NS.Object, duration: CFTimeInterval) { +@(objc_type=CommandBuffer, objc_name="presentDrawableAfterMinimumDuration") +CommandBuffer_presentDrawableAfterMinimumDuration :: #force_inline proc(self: ^CommandBuffer, drawable: ^Drawable, duration: CFTimeInterval) { msgSend(nil, self, "presentDrawable:afterMinimumDuration:", drawable, duration) } -@(objc_type=CommandBuffer, objc_name="presentDrawable_atTime_") -CommandBuffer_presentDrawable_atTime_ :: #force_inline proc(self: ^CommandBuffer, drawable: ^NS.Object, presentationTime: CFTimeInterval) { +@(objc_type=CommandBuffer, objc_name="presentDrawableAtTime") +CommandBuffer_presentDrawableAtTime :: #force_inline proc(self: ^CommandBuffer, drawable: ^Drawable, presentationTime: CFTimeInterval) { msgSend(nil, self, "presentDrawable:atTime:", drawable, presentationTime) } @(objc_type=CommandBuffer, objc_name="pushDebugGroup") @@ -5630,7 +5683,7 @@ ComputeCommandEncoder_dispatchThreadgroups :: #force_inline proc(self: ^ComputeC msgSend(nil, self, "dispatchThreadgroups:threadsPerThreadgroup:", threadgroupsPerGrid, threadsPerThreadgroup) } @(objc_type=ComputeCommandEncoder, objc_name="dispatchThreadgroupsWithIndirectBuffer") -ComputeCommandEncoder_dispatchThreadgroupsWithIndirectBuffer :: #force_inline proc(self: ^ComputeCommandEncoder, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object, threadsPerThreadgroup: Size) { +ComputeCommandEncoder_dispatchThreadgroupsWithIndirectBuffer :: #force_inline proc(self: ^ComputeCommandEncoder, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger, threadsPerThreadgroup: Size) { msgSend(nil, self, "dispatchThreadgroupsWithIndirectBuffer:indirectBufferOffset:threadsPerThreadgroup:", indirectBuffer, indirectBufferOffset, threadsPerThreadgroup) } @(objc_type=ComputeCommandEncoder, objc_name="dispatchThreads") @@ -5641,16 +5694,16 @@ ComputeCommandEncoder_dispatchThreads :: #force_inline proc(self: ^ComputeComman ComputeCommandEncoder_dispatchType :: #force_inline proc(self: ^ComputeCommandEncoder) -> DispatchType { return msgSend(DispatchType, self, "dispatchType") } -@(objc_type=ComputeCommandEncoder, objc_name="executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_") -ComputeCommandEncoder_executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^ComputeCommandEncoder, indirectCommandbuffer: ^NS.Object, indirectRangeBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { +@(objc_type=ComputeCommandEncoder, objc_name="executeCommandsInBuffer") +ComputeCommandEncoder_executeCommandsInBuffer :: #force_inline proc(self: ^ComputeCommandEncoder, indirectCommandbuffer: ^Buffer, indirectRangeBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "executeCommandsInBuffer:indirectBuffer:indirectBufferOffset:", indirectCommandbuffer, indirectRangeBuffer, indirectBufferOffset) } -@(objc_type=ComputeCommandEncoder, objc_name="executeCommandsInBuffer_withRange_") -ComputeCommandEncoder_executeCommandsInBuffer_withRange_ :: #force_inline proc(self: ^ComputeCommandEncoder, indirectCommandBuffer: ^NS.Object, executionRange: NS.Range) { +@(objc_type=ComputeCommandEncoder, objc_name="executeCommandsInBufferWithRange") +ComputeCommandEncoder_executeCommandsInBufferWithRange :: #force_inline proc(self: ^ComputeCommandEncoder, indirectCommandBuffer: ^Buffer, executionRange: NS.Range) { msgSend(nil, self, "executeCommandsInBuffer:withRange:", indirectCommandBuffer, executionRange) } @(objc_type=ComputeCommandEncoder, objc_name="memoryBarrierWithResources") -ComputeCommandEncoder_memoryBarrierWithResources :: #force_inline proc(self: ^ComputeCommandEncoder, resources: ^^NS.Object, count: ^NS.Object) { +ComputeCommandEncoder_memoryBarrierWithResources :: #force_inline proc(self: ^ComputeCommandEncoder, resources: [^]^Resource, count: NS.UInteger) { msgSend(nil, self, "memoryBarrierWithResources:count:", resources, count) } @(objc_type=ComputeCommandEncoder, objc_name="memoryBarrierWithScope") @@ -5658,59 +5711,59 @@ ComputeCommandEncoder_memoryBarrierWithScope :: #force_inline proc(self: ^Comput msgSend(nil, self, "memoryBarrierWithScope:", scope) } @(objc_type=ComputeCommandEncoder, objc_name="sampleCountersInBuffer") -ComputeCommandEncoder_sampleCountersInBuffer :: #force_inline proc(self: ^ComputeCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) { +ComputeCommandEncoder_sampleCountersInBuffer :: #force_inline proc(self: ^ComputeCommandEncoder, sampleBuffer: ^Buffer, sampleIndex: NS.UInteger, barrier: BOOL) { msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier) } @(objc_type=ComputeCommandEncoder, objc_name="setAccelerationStructure") -ComputeCommandEncoder_setAccelerationStructure :: #force_inline proc(self: ^ComputeCommandEncoder, accelerationStructure: ^NS.Object, bufferIndex: ^NS.Object) { +ComputeCommandEncoder_setAccelerationStructure :: #force_inline proc(self: ^ComputeCommandEncoder, accelerationStructure: ^AccelerationStructure, bufferIndex: NS.UInteger) { msgSend(nil, self, "setAccelerationStructure:atBufferIndex:", accelerationStructure, bufferIndex) } @(objc_type=ComputeCommandEncoder, objc_name="setBuffer") -ComputeCommandEncoder_setBuffer :: #force_inline proc(self: ^ComputeCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +ComputeCommandEncoder_setBuffer :: #force_inline proc(self: ^ComputeCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=ComputeCommandEncoder, objc_name="setBufferOffset") -ComputeCommandEncoder_setBufferOffset :: #force_inline proc(self: ^ComputeCommandEncoder, offset: ^NS.Object, index: ^NS.Object) { +ComputeCommandEncoder_setBufferOffset :: #force_inline proc(self: ^ComputeCommandEncoder, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setBufferOffset:atIndex:", offset, index) } @(objc_type=ComputeCommandEncoder, objc_name="setBuffers") -ComputeCommandEncoder_setBuffers :: #force_inline proc(self: ^ComputeCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { +ComputeCommandEncoder_setBuffers :: #force_inline proc(self: ^ComputeCommandEncoder, buffers: [^]^Buffer, offsets: [^]NS.UInteger, range: NS.Range) { msgSend(nil, self, "setBuffers:offsets:withRange:", buffers, offsets, range) } @(objc_type=ComputeCommandEncoder, objc_name="setBytes") -ComputeCommandEncoder_setBytes :: #force_inline proc(self: ^ComputeCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) { +ComputeCommandEncoder_setBytes :: #force_inline proc(self: ^ComputeCommandEncoder, bytes: rawptr, length: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setBytes:length:atIndex:", bytes, length, index) } @(objc_type=ComputeCommandEncoder, objc_name="setComputePipelineState") -ComputeCommandEncoder_setComputePipelineState :: #force_inline proc(self: ^ComputeCommandEncoder, pipelineState: ^NS.Object) { +ComputeCommandEncoder_setComputePipelineState :: #force_inline proc(self: ^ComputeCommandEncoder, pipelineState: ^ComputePipelineState) { msgSend(nil, self, "setComputePipelineState:", pipelineState) } @(objc_type=ComputeCommandEncoder, objc_name="setImageblockWidth") -ComputeCommandEncoder_setImageblockWidth :: #force_inline proc(self: ^ComputeCommandEncoder, width: ^NS.Object, height: ^NS.Object) { +ComputeCommandEncoder_setImageblockWidth :: #force_inline proc(self: ^ComputeCommandEncoder, width: NS.UInteger, height: NS.UInteger) { msgSend(nil, self, "setImageblockWidth:height:", width, height) } @(objc_type=ComputeCommandEncoder, objc_name="setIntersectionFunctionTable") -ComputeCommandEncoder_setIntersectionFunctionTable :: #force_inline proc(self: ^ComputeCommandEncoder, intersectionFunctionTable: ^NS.Object, bufferIndex: ^NS.Object) { +ComputeCommandEncoder_setIntersectionFunctionTable :: #force_inline proc(self: ^ComputeCommandEncoder, intersectionFunctionTable: ^IntersectionFunctionTable, bufferIndex: NS.UInteger) { msgSend(nil, self, "setIntersectionFunctionTable:atBufferIndex:", intersectionFunctionTable, bufferIndex) } @(objc_type=ComputeCommandEncoder, objc_name="setIntersectionFunctionTables") -ComputeCommandEncoder_setIntersectionFunctionTables :: #force_inline proc(self: ^ComputeCommandEncoder, intersectionFunctionTables: ^^NS.Object, range: NS.Range) { +ComputeCommandEncoder_setIntersectionFunctionTables :: #force_inline proc(self: ^ComputeCommandEncoder, intersectionFunctionTables: [^]^IntersectionFunctionTable, range: NS.Range) { msgSend(nil, self, "setIntersectionFunctionTables:withBufferRange:", intersectionFunctionTables, range) } -@(objc_type=ComputeCommandEncoder, objc_name="setSamplerState_atIndex_") -ComputeCommandEncoder_setSamplerState_atIndex_ :: #force_inline proc(self: ^ComputeCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) { +@(objc_type=ComputeCommandEncoder, objc_name="setSamplerStateAtIndex") +ComputeCommandEncoder_setSamplerStateAtIndex :: #force_inline proc(self: ^ComputeCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { msgSend(nil, self, "setSamplerState:atIndex:", sampler, index) } -@(objc_type=ComputeCommandEncoder, objc_name="setSamplerState_lodMinClamp_lodMaxClamp_atIndex_") -ComputeCommandEncoder_setSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: #force_inline proc(self: ^ComputeCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) { +@(objc_type=ComputeCommandEncoder, objc_name="setSamplerState_lodMinClamp_lodMaxClampAtIndex") +ComputeCommandEncoder_setSamplerState_lodMinClamp_lodMaxClampAtIndex :: #force_inline proc(self: ^ComputeCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { msgSend(nil, self, "setSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } -@(objc_type=ComputeCommandEncoder, objc_name="setSamplerStates_lodMinClamps_lodMaxClamps_withRange_") -ComputeCommandEncoder_setSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: #force_inline proc(self: ^ComputeCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { +@(objc_type=ComputeCommandEncoder, objc_name="setSamplerStates_lodMinClamps_lodMaxClampsWithRange") +ComputeCommandEncoder_setSamplerStates_lodMinClamps_lodMaxClampsWithRange :: #force_inline proc(self: ^ComputeCommandEncoder, samplers: [^]^SamplerState, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { msgSend(nil, self, "setSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range) } -@(objc_type=ComputeCommandEncoder, objc_name="setSamplerStates_withRange_") -ComputeCommandEncoder_setSamplerStates_withRange_ :: #force_inline proc(self: ^ComputeCommandEncoder, samplers: ^^NS.Object, range: NS.Range) { +@(objc_type=ComputeCommandEncoder, objc_name="setSamplerStatesWithRange") +ComputeCommandEncoder_setSamplerStatesWithRange :: #force_inline proc(self: ^ComputeCommandEncoder, samplers: [^]^SamplerState, range: NS.Range) { msgSend(nil, self, "setSamplerStates:withRange:", samplers, range) } @(objc_type=ComputeCommandEncoder, objc_name="setStageInRegion") @@ -5718,51 +5771,51 @@ ComputeCommandEncoder_setStageInRegion :: #force_inline proc(self: ^ComputeComma msgSend(nil, self, "setStageInRegion:", region) } @(objc_type=ComputeCommandEncoder, objc_name="setStageInRegionWithIndirectBuffer") -ComputeCommandEncoder_setStageInRegionWithIndirectBuffer :: #force_inline proc(self: ^ComputeCommandEncoder, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { +ComputeCommandEncoder_setStageInRegionWithIndirectBuffer :: #force_inline proc(self: ^ComputeCommandEncoder, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "setStageInRegionWithIndirectBuffer:indirectBufferOffset:", indirectBuffer, indirectBufferOffset) } @(objc_type=ComputeCommandEncoder, objc_name="setTexture") -ComputeCommandEncoder_setTexture :: #force_inline proc(self: ^ComputeCommandEncoder, texture: ^NS.Object, index: ^NS.Object) { +ComputeCommandEncoder_setTexture :: #force_inline proc(self: ^ComputeCommandEncoder, texture: ^Texture, index: NS.UInteger) { msgSend(nil, self, "setTexture:atIndex:", texture, index) } @(objc_type=ComputeCommandEncoder, objc_name="setTextures") -ComputeCommandEncoder_setTextures :: #force_inline proc(self: ^ComputeCommandEncoder, textures: ^^NS.Object, range: NS.Range) { +ComputeCommandEncoder_setTextures :: #force_inline proc(self: ^ComputeCommandEncoder, textures: [^]^Texture, range: NS.Range) { msgSend(nil, self, "setTextures:withRange:", textures, range) } @(objc_type=ComputeCommandEncoder, objc_name="setThreadgroupMemoryLength") -ComputeCommandEncoder_setThreadgroupMemoryLength :: #force_inline proc(self: ^ComputeCommandEncoder, length: ^NS.Object, index: ^NS.Object) { +ComputeCommandEncoder_setThreadgroupMemoryLength :: #force_inline proc(self: ^ComputeCommandEncoder, length: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setThreadgroupMemoryLength:atIndex:", length, index) } @(objc_type=ComputeCommandEncoder, objc_name="setVisibleFunctionTable") -ComputeCommandEncoder_setVisibleFunctionTable :: #force_inline proc(self: ^ComputeCommandEncoder, visibleFunctionTable: ^NS.Object, bufferIndex: ^NS.Object) { +ComputeCommandEncoder_setVisibleFunctionTable :: #force_inline proc(self: ^ComputeCommandEncoder, visibleFunctionTable: ^VisibleFunctionTable, bufferIndex: NS.UInteger) { msgSend(nil, self, "setVisibleFunctionTable:atBufferIndex:", visibleFunctionTable, bufferIndex) } @(objc_type=ComputeCommandEncoder, objc_name="setVisibleFunctionTables") -ComputeCommandEncoder_setVisibleFunctionTables :: #force_inline proc(self: ^ComputeCommandEncoder, visibleFunctionTables: ^^NS.Object, range: NS.Range) { +ComputeCommandEncoder_setVisibleFunctionTables :: #force_inline proc(self: ^ComputeCommandEncoder, visibleFunctionTables: [^]^VisibleFunctionTable, range: NS.Range) { msgSend(nil, self, "setVisibleFunctionTables:withBufferRange:", visibleFunctionTables, range) } @(objc_type=ComputeCommandEncoder, objc_name="updateFence") -ComputeCommandEncoder_updateFence :: #force_inline proc(self: ^ComputeCommandEncoder, fence: ^NS.Object) { +ComputeCommandEncoder_updateFence :: #force_inline proc(self: ^ComputeCommandEncoder, fence: ^Fence) { msgSend(nil, self, "updateFence:", fence) } @(objc_type=ComputeCommandEncoder, objc_name="useHeap") -ComputeCommandEncoder_useHeap :: #force_inline proc(self: ^ComputeCommandEncoder, heap: ^NS.Object) { +ComputeCommandEncoder_useHeap :: #force_inline proc(self: ^ComputeCommandEncoder, heap: ^Heap) { msgSend(nil, self, "useHeap:", heap) } @(objc_type=ComputeCommandEncoder, objc_name="useHeaps") -ComputeCommandEncoder_useHeaps :: #force_inline proc(self: ^ComputeCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object) { +ComputeCommandEncoder_useHeaps :: #force_inline proc(self: ^ComputeCommandEncoder, heaps: [^]^Heap, count: NS.UInteger) { msgSend(nil, self, "useHeaps:count:", heaps, count) } @(objc_type=ComputeCommandEncoder, objc_name="useResource") -ComputeCommandEncoder_useResource :: #force_inline proc(self: ^ComputeCommandEncoder, resource: ^NS.Object, usage: ResourceUsage) { +ComputeCommandEncoder_useResource :: #force_inline proc(self: ^ComputeCommandEncoder, resource: ^Resource, usage: ResourceUsage) { msgSend(nil, self, "useResource:usage:", resource, usage) } @(objc_type=ComputeCommandEncoder, objc_name="useResources") -ComputeCommandEncoder_useResources :: #force_inline proc(self: ^ComputeCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage) { +ComputeCommandEncoder_useResources :: #force_inline proc(self: ^ComputeCommandEncoder, resources: [^]^Resource, count: NS.UInteger, usage: ResourceUsage) { msgSend(nil, self, "useResources:count:usage:", resources, count, usage) } @(objc_type=ComputeCommandEncoder, objc_name="waitForFence") -ComputeCommandEncoder_waitForFence :: #force_inline proc(self: ^ComputeCommandEncoder, fence: ^NS.Object) { +ComputeCommandEncoder_waitForFence :: #force_inline proc(self: ^ComputeCommandEncoder, fence: ^Fence) { msgSend(nil, self, "waitForFence:", fence) } @@ -5793,7 +5846,7 @@ ComputePipelineState_device :: #force_inline proc(self: ^ComputePipelineState) - return msgSend(^ComputePipelineState, self, "device") } @(objc_type=ComputePipelineState, objc_name="functionHandleWithFunction") -ComputePipelineState_functionHandleWithFunction :: #force_inline proc(self: ^ComputePipelineState, function: ^NS.Object) -> ^ComputePipelineState { +ComputePipelineState_functionHandleWithFunction :: #force_inline proc(self: ^ComputePipelineState, function: ^Function) -> ^ComputePipelineState { return msgSend(^ComputePipelineState, self, "functionHandleWithFunction:", function) } @(objc_type=ComputePipelineState, objc_name="imageblockMemoryLengthForDimensions") @@ -5805,12 +5858,13 @@ ComputePipelineState_label :: #force_inline proc(self: ^ComputePipelineState) -> return msgSend(^NS.String, self, "label") } @(objc_type=ComputePipelineState, objc_name="maxTotalThreadsPerThreadgroup") -ComputePipelineState_maxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^ComputePipelineState) -> NS.Integer { - return msgSend(NS.Integer, self, "maxTotalThreadsPerThreadgroup") +ComputePipelineState_maxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^ComputePipelineState) -> NS.UInteger { + return msgSend(NS.UInteger, self, "maxTotalThreadsPerThreadgroup") } @(objc_type=ComputePipelineState, objc_name="newComputePipelineStateWithAdditionalBinaryFunctions") -ComputePipelineState_newComputePipelineStateWithAdditionalBinaryFunctions :: #force_inline proc(self: ^ComputePipelineState, functions: ^NS.Array, error: ^^NS.Error ) -> ^ComputePipelineState { - return msgSend(^ComputePipelineState, self, "newComputePipelineStateWithAdditionalBinaryFunctions:error:", functions, error) +ComputePipelineState_newComputePipelineStateWithAdditionalBinaryFunctions :: #force_inline proc(self: ^ComputePipelineState, functions: ^NS.Array) -> (state: ^ComputePipelineState, error: ^NS.Error) { + state = msgSend(^ComputePipelineState, self, "newComputePipelineStateWithAdditionalBinaryFunctions:error:", functions, &error) + return } @(objc_type=ComputePipelineState, objc_name="newIntersectionFunctionTableWithDescriptor") ComputePipelineState_newIntersectionFunctionTableWithDescriptor :: #force_inline proc(self: ^ComputePipelineState, descriptor: ^IntersectionFunctionTableDescriptor) -> ^ComputePipelineState { @@ -5821,16 +5875,16 @@ ComputePipelineState_newVisibleFunctionTableWithDescriptor :: #force_inline proc return msgSend(^ComputePipelineState, self, "newVisibleFunctionTableWithDescriptor:", descriptor) } @(objc_type=ComputePipelineState, objc_name="staticThreadgroupMemoryLength") -ComputePipelineState_staticThreadgroupMemoryLength :: #force_inline proc(self: ^ComputePipelineState) -> NS.Integer { - return msgSend(NS.Integer, self, "staticThreadgroupMemoryLength") +ComputePipelineState_staticThreadgroupMemoryLength :: #force_inline proc(self: ^ComputePipelineState) -> NS.UInteger { + return msgSend(NS.UInteger, self, "staticThreadgroupMemoryLength") } @(objc_type=ComputePipelineState, objc_name="supportIndirectCommandBuffers") ComputePipelineState_supportIndirectCommandBuffers :: #force_inline proc(self: ^ComputePipelineState) -> BOOL { return msgSend(BOOL, self, "supportIndirectCommandBuffers") } @(objc_type=ComputePipelineState, objc_name="threadExecutionWidth") -ComputePipelineState_threadExecutionWidth :: #force_inline proc(self: ^ComputePipelineState) -> NS.Integer { - return msgSend(NS.Integer, self, "threadExecutionWidth") +ComputePipelineState_threadExecutionWidth :: #force_inline proc(self: ^ComputePipelineState) -> NS.UInteger { + return msgSend(NS.UInteger, self, "threadExecutionWidth") } //////////////////////////////////////////////////////////////////////////////// @@ -5878,8 +5932,8 @@ CounterSampleBuffer_resolveCounterRange :: #force_inline proc(self: ^CounterSamp return msgSend(^NS.Data, self, "resolveCounterRange:", range) } @(objc_type=CounterSampleBuffer, objc_name="sampleCount") -CounterSampleBuffer_sampleCount :: #force_inline proc(self: ^CounterSampleBuffer) -> NS.Integer { - return msgSend(NS.Integer, self, "sampleCount") +CounterSampleBuffer_sampleCount :: #force_inline proc(self: ^CounterSampleBuffer) -> NS.UInteger { + return msgSend(NS.UInteger, self, "sampleCount") } //////////////////////////////////////////////////////////////////////////////// @@ -6053,11 +6107,11 @@ Device_argumentBuffersSupport :: #force_inline proc(self: ^Device) -> ArgumentBu return msgSend(ArgumentBuffersTier, self, "argumentBuffersSupport") } @(objc_type=Device, objc_name="convertSparsePixelRegions") -Device_convertSparsePixelRegions :: #force_inline proc(self: ^Device, pixelRegions: ^Region, tileRegions: ^Region, tileSize: Size, mode: SparseTextureRegionAlignmentMode, numRegions: ^NS.Object) { +Device_convertSparsePixelRegions :: #force_inline proc(self: ^Device, pixelRegions: ^Region, tileRegions: ^Region, tileSize: Size, mode: SparseTextureRegionAlignmentMode, numRegions: NS.UInteger) { msgSend(nil, self, "convertSparsePixelRegions:toTileRegions:withTileSize:alignmentMode:numRegions:", pixelRegions, tileRegions, tileSize, mode, numRegions) } @(objc_type=Device, objc_name="convertSparseTileRegions") -Device_convertSparseTileRegions :: #force_inline proc(self: ^Device, tileRegions: ^Region, pixelRegions: ^Region, tileSize: Size, numRegions: ^NS.Object) { +Device_convertSparseTileRegions :: #force_inline proc(self: ^Device, tileRegions: ^Region, pixelRegions: ^Region, tileSize: Size, numRegions: NS.UInteger) { msgSend(nil, self, "convertSparseTileRegions:toPixelRegions:withTileSize:numRegions:", tileRegions, pixelRegions, tileSize, numRegions) } @(objc_type=Device, objc_name="counterSets") @@ -6065,11 +6119,11 @@ Device_counterSets :: #force_inline proc(self: ^Device) -> ^NS.Array { return msgSend(^NS.Array, self, "counterSets") } @(objc_type=Device, objc_name="currentAllocatedSize") -Device_currentAllocatedSize :: #force_inline proc(self: ^Device) -> NS.Integer { - return msgSend(NS.Integer, self, "currentAllocatedSize") +Device_currentAllocatedSize :: #force_inline proc(self: ^Device) -> NS.UInteger { + return msgSend(NS.UInteger, self, "currentAllocatedSize") } @(objc_type=Device, objc_name="getDefaultSamplePositions") -Device_getDefaultSamplePositions :: #force_inline proc(self: ^Device, positions: ^SamplePosition, count: ^NS.Object) { +Device_getDefaultSamplePositions :: #force_inline proc(self: ^Device, positions: ^SamplePosition, count: NS.UInteger) { msgSend(nil, self, "getDefaultSamplePositions:count:", positions, count) } @(objc_type=Device, objc_name="hasUnifiedMemory") @@ -6077,7 +6131,7 @@ Device_hasUnifiedMemory :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "hasUnifiedMemory") } @(objc_type=Device, objc_name="heapBufferSizeAndAlignWithLength") -Device_heapBufferSizeAndAlignWithLength :: #force_inline proc(self: ^Device, length: ^NS.Object, options: ResourceOptions) -> SizeAndAlign { +Device_heapBufferSizeAndAlignWithLength :: #force_inline proc(self: ^Device, length: NS.UInteger, options: ResourceOptions) -> SizeAndAlign { return msgSend(SizeAndAlign, self, "heapBufferSizeAndAlignWithLength:options:", length, options) } @(objc_type=Device, objc_name="heapTextureSizeAndAlignWithDescriptor") @@ -6105,20 +6159,20 @@ Device_location :: #force_inline proc(self: ^Device) -> DeviceLocation { return msgSend(DeviceLocation, self, "location") } @(objc_type=Device, objc_name="locationNumber") -Device_locationNumber :: #force_inline proc(self: ^Device) -> NS.Integer { - return msgSend(NS.Integer, self, "locationNumber") +Device_locationNumber :: #force_inline proc(self: ^Device) -> NS.UInteger { + return msgSend(NS.UInteger, self, "locationNumber") } @(objc_type=Device, objc_name="maxArgumentBufferSamplerCount") -Device_maxArgumentBufferSamplerCount :: #force_inline proc(self: ^Device) -> NS.Integer { - return msgSend(NS.Integer, self, "maxArgumentBufferSamplerCount") +Device_maxArgumentBufferSamplerCount :: #force_inline proc(self: ^Device) -> NS.UInteger { + return msgSend(NS.UInteger, self, "maxArgumentBufferSamplerCount") } @(objc_type=Device, objc_name="maxBufferLength") -Device_maxBufferLength :: #force_inline proc(self: ^Device) -> NS.Integer { - return msgSend(NS.Integer, self, "maxBufferLength") +Device_maxBufferLength :: #force_inline proc(self: ^Device) -> NS.UInteger { + return msgSend(NS.UInteger, self, "maxBufferLength") } @(objc_type=Device, objc_name="maxThreadgroupMemoryLength") -Device_maxThreadgroupMemoryLength :: #force_inline proc(self: ^Device) -> NS.Integer { - return msgSend(NS.Integer, self, "maxThreadgroupMemoryLength") +Device_maxThreadgroupMemoryLength :: #force_inline proc(self: ^Device) -> NS.UInteger { + return msgSend(NS.UInteger, self, "maxThreadgroupMemoryLength") } @(objc_type=Device, objc_name="maxThreadsPerThreadgroup") Device_maxThreadsPerThreadgroup :: #force_inline proc(self: ^Device) -> Size { @@ -6145,7 +6199,7 @@ Device_newAccelerationStructureWithDescriptor :: #force_inline proc(self: ^Devic return msgSend(^Device, self, "newAccelerationStructureWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newAccelerationStructureWithSize") -Device_newAccelerationStructureWithSize :: #force_inline proc(self: ^Device, size: ^NS.Object) -> ^Device { +Device_newAccelerationStructureWithSize :: #force_inline proc(self: ^Device, size: NS.UInteger) -> ^Device { return msgSend(^Device, self, "newAccelerationStructureWithSize:", size) } @(objc_type=Device, objc_name="newArgumentEncoderWithArguments") @@ -6153,19 +6207,20 @@ Device_newArgumentEncoderWithArguments :: #force_inline proc(self: ^Device, argu return msgSend(^Device, self, "newArgumentEncoderWithArguments:", arguments) } @(objc_type=Device, objc_name="newBinaryArchiveWithDescriptor") -Device_newBinaryArchiveWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^BinaryArchiveDescriptor, error: ^^NS.Error ) -> ^Device { - return msgSend(^Device, self, "newBinaryArchiveWithDescriptor:error:", descriptor, error) +Device_newBinaryArchiveWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^BinaryArchiveDescriptor) -> (device: ^Device, error: ^NS.Error) { + device = msgSend(^Device, self, "newBinaryArchiveWithDescriptor:error:", descriptor, &error) + return } @(objc_type=Device, objc_name="newBufferWithBytes") -Device_newBufferWithBytes :: #force_inline proc(self: ^Device, pointer: rawptr, length: ^NS.Object, options: ResourceOptions) -> ^Device { +Device_newBufferWithBytes :: #force_inline proc(self: ^Device, pointer: rawptr, length: NS.UInteger, options: ResourceOptions) -> ^Device { return msgSend(^Device, self, "newBufferWithBytes:length:options:", pointer, length, options) } @(objc_type=Device, objc_name="newBufferWithBytesNoCopy") -Device_newBufferWithBytesNoCopy :: #force_inline proc(self: ^Device, pointer: rawptr, length: ^NS.Object, options: ResourceOptions, deallocator: rawptr) -> ^Device { +Device_newBufferWithBytesNoCopy :: #force_inline proc(self: ^Device, pointer: rawptr, length: NS.UInteger, options: ResourceOptions, deallocator: rawptr) -> ^Device { return msgSend(^Device, self, "newBufferWithBytesNoCopy:length:options:deallocator:", pointer, length, options, deallocator) } @(objc_type=Device, objc_name="newBufferWithLength") -Device_newBufferWithLength :: #force_inline proc(self: ^Device, length: ^NS.Object, options: ResourceOptions) -> ^Device { +Device_newBufferWithLength :: #force_inline proc(self: ^Device, length: NS.UInteger, options: ResourceOptions) -> ^Device { return msgSend(^Device, self, "newBufferWithLength:options:", length, options) } @(objc_type=Device, objc_name="newCommandQueue") @@ -6173,7 +6228,7 @@ Device_newCommandQueue :: #force_inline proc(self: ^Device) -> ^Device { return msgSend(^Device, self, "newCommandQueue") } @(objc_type=Device, objc_name="newCommandQueueWithMaxCommandBufferCount") -Device_newCommandQueueWithMaxCommandBufferCount :: #force_inline proc(self: ^Device, maxCommandBufferCount: ^NS.Object) -> ^Device { +Device_newCommandQueueWithMaxCommandBufferCount :: #force_inline proc(self: ^Device, maxCommandBufferCount: NS.UInteger) -> ^Device { return msgSend(^Device, self, "newCommandQueueWithMaxCommandBufferCount:", maxCommandBufferCount) } @(objc_type=Device, objc_name="newComputePipelineStateWithDescriptor_options_completionHandler_") @@ -6181,48 +6236,55 @@ Device_newComputePipelineStateWithDescriptor_options_completionHandler_ :: #forc msgSend(nil, self, "newComputePipelineStateWithDescriptor:options:completionHandler:", descriptor, options, completionHandler) } @(objc_type=Device, objc_name="newComputePipelineStateWithDescriptor_options_reflection_error_") -Device_newComputePipelineStateWithDescriptor_options_reflection_error_ :: #force_inline proc(self: ^Device, descriptor: ^ComputePipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection, error: ^^NS.Error ) -> ^Device { - return msgSend(^Device, self, "newComputePipelineStateWithDescriptor:options:reflection:error:", descriptor, options, reflection, error) +Device_newComputePipelineStateWithDescriptor_options_reflection_error_ :: #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) + return } @(objc_type=Device, objc_name="newComputePipelineStateWithFunction_completionHandler_") -Device_newComputePipelineStateWithFunction_completionHandler_ :: #force_inline proc(self: ^Device, computeFunction: ^NS.Object, completionHandler: NewComputePipelineStateCompletionHandler) { +Device_newComputePipelineStateWithFunction_completionHandler_ :: #force_inline proc(self: ^Device, computeFunction: ^Function, completionHandler: NewComputePipelineStateCompletionHandler) { msgSend(nil, self, "newComputePipelineStateWithFunction:completionHandler:", computeFunction, completionHandler) } @(objc_type=Device, objc_name="newComputePipelineStateWithFunction_error_") -Device_newComputePipelineStateWithFunction_error_ :: #force_inline proc(self: ^Device, computeFunction: ^NS.Object, error: ^^NS.Error ) -> ^Device { - return msgSend(^Device, self, "newComputePipelineStateWithFunction:error:", computeFunction, error) +Device_newComputePipelineStateWithFunction_error_ :: #force_inline proc(self: ^Device, computeFunction: ^Function) -> (device: ^Device, error: ^NS.Error) { + device = msgSend(^Device, self, "newComputePipelineStateWithFunction:error:", computeFunction, &error) + return } @(objc_type=Device, objc_name="newComputePipelineStateWithFunction_options_completionHandler_") -Device_newComputePipelineStateWithFunction_options_completionHandler_ :: #force_inline proc(self: ^Device, computeFunction: ^NS.Object, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) { +Device_newComputePipelineStateWithFunction_options_completionHandler_ :: #force_inline proc(self: ^Device, computeFunction: ^Function, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) { msgSend(nil, self, "newComputePipelineStateWithFunction:options:completionHandler:", computeFunction, options, completionHandler) } @(objc_type=Device, objc_name="newComputePipelineStateWithFunction_options_reflection_error_") -Device_newComputePipelineStateWithFunction_options_reflection_error_ :: #force_inline proc(self: ^Device, computeFunction: ^NS.Object, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection, error: ^^NS.Error ) -> ^Device { - return msgSend(^Device, self, "newComputePipelineStateWithFunction:options:reflection:error:", computeFunction, options, reflection, error) +Device_newComputePipelineStateWithFunction_options_reflection_error_ :: #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) + return } @(objc_type=Device, objc_name="newCounterSampleBufferWithDescriptor") -Device_newCounterSampleBufferWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^CounterSampleBufferDescriptor, error: ^^NS.Error ) -> ^Device { - return msgSend(^Device, self, "newCounterSampleBufferWithDescriptor:error:", descriptor, error) +Device_newCounterSampleBufferWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^CounterSampleBufferDescriptor) -> (device: ^Device, error: ^NS.Error) { + device = msgSend(^Device, self, "newCounterSampleBufferWithDescriptor:error:", descriptor, &error) + return } @(objc_type=Device, objc_name="newDefaultLibrary") Device_newDefaultLibrary :: #force_inline proc(self: ^Device) -> ^Device { return msgSend(^Device, self, "newDefaultLibrary") } @(objc_type=Device, objc_name="newDefaultLibraryWithBundle") -Device_newDefaultLibraryWithBundle :: #force_inline proc(self: ^Device, bundle: ^NS.Bundle, error: ^^NS.Error ) -> ^Device { - return msgSend(^Device, self, "newDefaultLibraryWithBundle:error:", bundle, error) +Device_newDefaultLibraryWithBundle :: #force_inline proc(self: ^Device, bundle: ^NS.Bundle) -> (device: ^Device, error: ^NS.Error) { + device = msgSend(^Device, self, "newDefaultLibraryWithBundle:error:", bundle, &error) + return } @(objc_type=Device, objc_name="newDepthStencilStateWithDescriptor") Device_newDepthStencilStateWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^DepthStencilDescriptor) -> ^Device { return msgSend(^Device, self, "newDepthStencilStateWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newDynamicLibrary") -Device_newDynamicLibrary :: #force_inline proc(self: ^Device, library: ^NS.Object, error: ^^NS.Error ) -> ^Device { - return msgSend(^Device, self, "newDynamicLibrary:error:", library, error) +Device_newDynamicLibrary :: #force_inline proc(self: ^Device, library: ^Library) -> (device: ^Device, error: ^NS.Error) { + device = msgSend(^Device, self, "newDynamicLibrary:error:", library, &error) + return } @(objc_type=Device, objc_name="newDynamicLibraryWithURL") -Device_newDynamicLibraryWithURL :: #force_inline proc(self: ^Device, url: ^NS.URL, error: ^^NS.Error ) -> ^Device { - return msgSend(^Device, self, "newDynamicLibraryWithURL:error:", url, error) +Device_newDynamicLibraryWithURL :: #force_inline proc(self: ^Device, url: ^NS.URL) -> (device: ^Device, error: ^NS.Error) { + device = msgSend(^Device, self, "newDynamicLibraryWithURL:error:", url, &error) + return } @(objc_type=Device, objc_name="newEvent") Device_newEvent :: #force_inline proc(self: ^Device) -> ^Device { @@ -6237,28 +6299,32 @@ Device_newHeapWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^H return msgSend(^Device, self, "newHeapWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newIndirectCommandBufferWithDescriptor") -Device_newIndirectCommandBufferWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^IndirectCommandBufferDescriptor, maxCount: ^NS.Object, options: ResourceOptions) -> ^Device { +Device_newIndirectCommandBufferWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^IndirectCommandBufferDescriptor, maxCount: NS.UInteger, options: ResourceOptions) -> ^Device { return msgSend(^Device, self, "newIndirectCommandBufferWithDescriptor:maxCommandCount:options:", descriptor, maxCount, options) } @(objc_type=Device, objc_name="newLibraryWithData") -Device_newLibraryWithData :: #force_inline proc(self: ^Device, data: ^NS.Object, error: ^^NS.Error ) -> ^Device { - return msgSend(^Device, self, "newLibraryWithData:error:", data, error) +Device_newLibraryWithData :: #force_inline proc(self: ^Device, data: dispatch_data_t) -> (device: ^Device, error: ^NS.Error) { + device = msgSend(^Device, self, "newLibraryWithData:error:", data, &error) + return } @(objc_type=Device, objc_name="newLibraryWithFile") -Device_newLibraryWithFile :: #force_inline proc(self: ^Device, filepath: ^NS.String, error: ^^NS.Error ) -> ^Device { - return msgSend(^Device, self, "newLibraryWithFile:error:", filepath, error) +Device_newLibraryWithFile :: #force_inline proc(self: ^Device, filepath: ^NS.String) -> (device: ^Device, error: ^NS.Error) { + device = msgSend(^Device, self, "newLibraryWithFile:error:", filepath, &error) + return } @(objc_type=Device, objc_name="newLibraryWithSource_options_completionHandler_") Device_newLibraryWithSource_options_completionHandler_ :: #force_inline proc(self: ^Device, source: ^NS.String, options: ^CompileOptions, completionHandler: NewLibraryCompletionHandler) { msgSend(nil, self, "newLibraryWithSource:options:completionHandler:", source, options, completionHandler) } @(objc_type=Device, objc_name="newLibraryWithSource_options_error_") -Device_newLibraryWithSource_options_error_ :: #force_inline proc(self: ^Device, source: ^NS.String, options: ^CompileOptions, error: ^^NS.Error ) -> ^Device { - return msgSend(^Device, self, "newLibraryWithSource:options:error:", source, options, error) +Device_newLibraryWithSource_options_error_ :: #force_inline proc(self: ^Device, source: ^NS.String, options: ^CompileOptions) -> (device: ^Device, error: ^NS.Error) { + device = msgSend(^Device, self, "newLibraryWithSource:options:error:", source, options, &error) + return } @(objc_type=Device, objc_name="newLibraryWithURL") -Device_newLibraryWithURL :: #force_inline proc(self: ^Device, url: ^NS.URL, error: ^^NS.Error ) -> ^Device { - return msgSend(^Device, self, "newLibraryWithURL:error:", url, error) +Device_newLibraryWithURL :: #force_inline proc(self: ^Device, url: ^NS.URL) -> (device: ^Device, error: ^NS.Error) { + device = msgSend(^Device, self, "newLibraryWithURL:error:", url, &error) + return } @(objc_type=Device, objc_name="newRasterizationRateMapWithDescriptor") Device_newRasterizationRateMapWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^RasterizationRateMapDescriptor) -> ^Device { @@ -6269,24 +6335,27 @@ Device_newRenderPipelineStateWithDescriptor_completionHandler_ :: #force_inline msgSend(nil, self, "newRenderPipelineStateWithDescriptor:completionHandler:", descriptor, completionHandler) } @(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor_error_") -Device_newRenderPipelineStateWithDescriptor_error_ :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, error: ^^NS.Error ) -> ^Device { - return msgSend(^Device, self, "newRenderPipelineStateWithDescriptor:error:", descriptor, error) +Device_newRenderPipelineStateWithDescriptor_error_ :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor) -> (device: ^Device, error: ^NS.Error) { + device = msgSend(^Device, self, "newRenderPipelineStateWithDescriptor:error:", descriptor, &error) + return } @(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor_options_completionHandler_") Device_newRenderPipelineStateWithDescriptor_options_completionHandler_ :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, completionHandler: NewRenderPipelineStateWithReflectionCompletionHandler) { msgSend(nil, self, "newRenderPipelineStateWithDescriptor:options:completionHandler:", descriptor, options, completionHandler) } @(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor_options_reflection_error_") -Device_newRenderPipelineStateWithDescriptor_options_reflection_error_ :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection, error: ^^NS.Error ) -> ^Device { - return msgSend(^Device, self, "newRenderPipelineStateWithDescriptor:options:reflection:error:", descriptor, options, reflection, error) +Device_newRenderPipelineStateWithDescriptor_options_reflection_error_ :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection) -> (device: ^Device, error: ^NS.Error) { + device = msgSend(^Device, self, "newRenderPipelineStateWithDescriptor:options:reflection:error:", descriptor, options, reflection, &error) + return } @(objc_type=Device, objc_name="newRenderPipelineStateWithTileDescriptor_options_completionHandler_") Device_newRenderPipelineStateWithTileDescriptor_options_completionHandler_ :: #force_inline proc(self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, completionHandler: NewRenderPipelineStateWithReflectionCompletionHandler) { msgSend(nil, self, "newRenderPipelineStateWithTileDescriptor:options:completionHandler:", descriptor, options, completionHandler) } @(objc_type=Device, objc_name="newRenderPipelineStateWithTileDescriptor_options_reflection_error_") -Device_newRenderPipelineStateWithTileDescriptor_options_reflection_error_ :: #force_inline proc(self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection, error: ^^NS.Error ) -> ^Device { - return msgSend(^Device, self, "newRenderPipelineStateWithTileDescriptor:options:reflection:error:", descriptor, options, reflection, error) +Device_newRenderPipelineStateWithTileDescriptor_options_reflection_error_ :: #force_inline proc(self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection) -> (device: ^Device, error: ^NS.Error) { + device = msgSend(^Device, self, "newRenderPipelineStateWithTileDescriptor:options:reflection:error:", descriptor, options, reflection, &error) + return } @(objc_type=Device, objc_name="newSamplerStateWithDescriptor") Device_newSamplerStateWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^SamplerDescriptor) -> ^Device { @@ -6313,7 +6382,7 @@ Device_newTextureWithDescriptor :: #force_inline proc(self: ^Device, desc: ^Text return msgSend(^Device, self, "newTextureWithDescriptor:", desc) } @(objc_type=Device, objc_name="newTextureWithDescriptor_iosurface_plane_") -Device_newTextureWithDescriptor_iosurface_plane_ :: #force_inline proc(self: ^Device, descriptor: ^TextureDescriptor, iosurface: IOSurfaceRef, plane: ^NS.Object) -> ^Device { +Device_newTextureWithDescriptor_iosurface_plane_ :: #force_inline proc(self: ^Device, descriptor: ^TextureDescriptor, iosurface: IOSurfaceRef, plane: NS.UInteger) -> ^Device { return msgSend(^Device, self, "newTextureWithDescriptor:iosurface:plane:", descriptor, iosurface, plane) } @(objc_type=Device, objc_name="peerCount") @@ -6345,11 +6414,11 @@ Device_sampleTimestamps :: #force_inline proc(self: ^Device, cpuTimestamp: ^Time msgSend(nil, self, "sampleTimestamps:gpuTimestamp:", cpuTimestamp, gpuTimestamp) } @(objc_type=Device, objc_name="sparseTileSizeInBytes") -Device_sparseTileSizeInBytes :: #force_inline proc(self: ^Device) -> NS.Integer { - return msgSend(NS.Integer, self, "sparseTileSizeInBytes") +Device_sparseTileSizeInBytes :: #force_inline proc(self: ^Device) -> NS.UInteger { + return msgSend(NS.UInteger, self, "sparseTileSizeInBytes") } @(objc_type=Device, objc_name="sparseTileSizeWithTextureType") -Device_sparseTileSizeWithTextureType :: #force_inline proc(self: ^Device, textureType: TextureType, pixelFormat: PixelFormat, sampleCount: ^NS.Object) -> Size { +Device_sparseTileSizeWithTextureType :: #force_inline proc(self: ^Device, textureType: TextureType, pixelFormat: PixelFormat, sampleCount: NS.UInteger) -> Size { return msgSend(Size, self, "sparseTileSizeWithTextureType:pixelFormat:sampleCount:", textureType, pixelFormat, sampleCount) } @(objc_type=Device, objc_name="supports32BitFloatFiltering") @@ -6393,7 +6462,7 @@ Device_supportsQueryTextureLOD :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "supportsQueryTextureLOD") } @(objc_type=Device, objc_name="supportsRasterizationRateMapWithLayerCount") -Device_supportsRasterizationRateMapWithLayerCount :: #force_inline proc(self: ^Device, layerCount: ^NS.Object) -> BOOL { +Device_supportsRasterizationRateMapWithLayerCount :: #force_inline proc(self: ^Device, layerCount: NS.UInteger) -> BOOL { return msgSend(BOOL, self, "supportsRasterizationRateMapWithLayerCount:", layerCount) } @(objc_type=Device, objc_name="supportsRaytracing") @@ -6405,11 +6474,11 @@ Device_supportsShaderBarycentricCoordinates :: #force_inline proc(self: ^Device) return msgSend(BOOL, self, "supportsShaderBarycentricCoordinates") } @(objc_type=Device, objc_name="supportsTextureSampleCount") -Device_supportsTextureSampleCount :: #force_inline proc(self: ^Device, sampleCount: ^NS.Object) -> BOOL { +Device_supportsTextureSampleCount :: #force_inline proc(self: ^Device, sampleCount: NS.UInteger) -> BOOL { return msgSend(BOOL, self, "supportsTextureSampleCount:", sampleCount) } @(objc_type=Device, objc_name="supportsVertexAmplificationCount") -Device_supportsVertexAmplificationCount :: #force_inline proc(self: ^Device, count: ^NS.Object) -> BOOL { +Device_supportsVertexAmplificationCount :: #force_inline proc(self: ^Device, count: NS.UInteger) -> BOOL { return msgSend(BOOL, self, "supportsVertexAmplificationCount:", count) } @@ -6435,8 +6504,8 @@ Drawable_addPresentedHandler :: #force_inline proc(self: ^Drawable, block: Drawa msgSend(nil, self, "addPresentedHandler:", block) } @(objc_type=Drawable, objc_name="drawableID") -Drawable_drawableID :: #force_inline proc(self: ^Drawable) -> NS.Integer { - return msgSend(NS.Integer, self, "drawableID") +Drawable_drawableID :: #force_inline proc(self: ^Drawable) -> NS.UInteger { + return msgSend(NS.UInteger, self, "drawableID") } @(objc_type=Drawable, objc_name="present") Drawable_present :: #force_inline proc(self: ^Drawable) { @@ -6484,8 +6553,9 @@ DynamicLibrary_label :: #force_inline proc(self: ^DynamicLibrary) -> ^NS.String return msgSend(^NS.String, self, "label") } @(objc_type=DynamicLibrary, objc_name="serializeToURL") -DynamicLibrary_serializeToURL :: #force_inline proc(self: ^DynamicLibrary, url: ^NS.URL, error: ^^NS.Error ) -> BOOL { - return msgSend(BOOL, self, "serializeToURL:error:", url, error) +DynamicLibrary_serializeToURL :: #force_inline proc(self: ^DynamicLibrary, url: ^NS.URL) -> (ok: bool, error: ^NS.Error) { + ok = msgSend(BOOL, self, "serializeToURL:error:", url, &error) + return } @(objc_type=DynamicLibrary, objc_name="setLabel") DynamicLibrary_setLabel :: #force_inline proc(self: ^DynamicLibrary, label: ^NS.String) { @@ -6591,11 +6661,11 @@ Function_name :: #force_inline proc(self: ^Function) -> ^NS.String { return msgSend(^NS.String, self, "name") } @(objc_type=Function, objc_name="newArgumentEncoderWithBufferIndex") -Function_newArgumentEncoderWithBufferIndex :: #force_inline proc(self: ^Function, bufferIndex: ^NS.Object) -> ^Function { +Function_newArgumentEncoderWithBufferIndex :: #force_inline proc(self: ^Function, bufferIndex: NS.UInteger) -> ^Function { return msgSend(^Function, self, "newArgumentEncoderWithBufferIndex:", bufferIndex) } @(objc_type=Function, objc_name="newArgumentEncoderWithBufferIndex_reflection_") -Function_newArgumentEncoderWithBufferIndex_reflection_ :: #force_inline proc(self: ^Function, bufferIndex: ^NS.Object, reflection: ^AutoreleasedArgument) -> ^Function { +Function_newArgumentEncoderWithBufferIndex_reflection_ :: #force_inline proc(self: ^Function, bufferIndex: NS.UInteger, reflection: ^AutoreleasedArgument) -> ^Function { return msgSend(^Function, self, "newArgumentEncoderWithBufferIndex:reflection:", bufferIndex, reflection) } @(objc_type=Function, objc_name="options") @@ -6603,8 +6673,8 @@ Function_options :: #force_inline proc(self: ^Function) -> FunctionOptions { return msgSend(FunctionOptions, self, "options") } @(objc_type=Function, objc_name="patchControlPointCount") -Function_patchControlPointCount :: #force_inline proc(self: ^Function) -> NS.Integer { - return msgSend(NS.Integer, self, "patchControlPointCount") +Function_patchControlPointCount :: #force_inline proc(self: ^Function) -> NS.UInteger { + return msgSend(NS.UInteger, self, "patchControlPointCount") } @(objc_type=Function, objc_name="patchType") Function_patchType :: #force_inline proc(self: ^Function) -> PatchType { @@ -6702,16 +6772,16 @@ FunctionLogDebugLocation_URL :: #force_inline proc(self: ^FunctionLogDebugLocati return msgSend(^NS.URL, self, "URL") } @(objc_type=FunctionLogDebugLocation, objc_name="column") -FunctionLogDebugLocation_column :: #force_inline proc(self: ^FunctionLogDebugLocation) -> NS.Integer { - return msgSend(NS.Integer, self, "column") +FunctionLogDebugLocation_column :: #force_inline proc(self: ^FunctionLogDebugLocation) -> NS.UInteger { + return msgSend(NS.UInteger, self, "column") } @(objc_type=FunctionLogDebugLocation, objc_name="functionName") FunctionLogDebugLocation_functionName :: #force_inline proc(self: ^FunctionLogDebugLocation) -> ^NS.String { return msgSend(^NS.String, self, "functionName") } @(objc_type=FunctionLogDebugLocation, objc_name="line") -FunctionLogDebugLocation_line :: #force_inline proc(self: ^FunctionLogDebugLocation) -> NS.Integer { - return msgSend(NS.Integer, self, "line") +FunctionLogDebugLocation_line :: #force_inline proc(self: ^FunctionLogDebugLocation) -> NS.UInteger { + return msgSend(NS.UInteger, self, "line") } //////////////////////////////////////////////////////////////////////////////// @@ -6747,8 +6817,8 @@ Heap_cpuCacheMode :: #force_inline proc(self: ^Heap) -> CPUCacheMode { return msgSend(CPUCacheMode, self, "cpuCacheMode") } @(objc_type=Heap, objc_name="currentAllocatedSize") -Heap_currentAllocatedSize :: #force_inline proc(self: ^Heap) -> NS.Integer { - return msgSend(NS.Integer, self, "currentAllocatedSize") +Heap_currentAllocatedSize :: #force_inline proc(self: ^Heap) -> NS.UInteger { + return msgSend(NS.UInteger, self, "currentAllocatedSize") } @(objc_type=Heap, objc_name="device") Heap_device :: #force_inline proc(self: ^Heap) -> ^Heap { @@ -6763,15 +6833,15 @@ Heap_label :: #force_inline proc(self: ^Heap) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=Heap, objc_name="maxAvailableSizeWithAlignment") -Heap_maxAvailableSizeWithAlignment :: #force_inline proc(self: ^Heap, alignment: ^NS.Object) -> ^Heap { +Heap_maxAvailableSizeWithAlignment :: #force_inline proc(self: ^Heap, alignment: NS.UInteger) -> ^Heap { return msgSend(^Heap, self, "maxAvailableSizeWithAlignment:", alignment) } @(objc_type=Heap, objc_name="newBufferWithLength") -Heap_newBufferWithLength :: #force_inline proc(self: ^Heap, length: ^NS.Object, options: ResourceOptions) -> ^Heap { +Heap_newBufferWithLength :: #force_inline proc(self: ^Heap, length: NS.UInteger, options: ResourceOptions) -> ^Heap { return msgSend(^Heap, self, "newBufferWithLength:options:", length, options) } @(objc_type=Heap, objc_name="newBufferWithLength_options_offset_") -Heap_newBufferWithLength_options_offset_ :: #force_inline proc(self: ^Heap, length: ^NS.Object, options: ResourceOptions, offset: ^NS.Object) -> ^Heap { +Heap_newBufferWithLength_options_offset_ :: #force_inline proc(self: ^Heap, length: NS.UInteger, options: ResourceOptions, offset: NS.UInteger) -> ^Heap { return msgSend(^Heap, self, "newBufferWithLength:options:offset:", length, options, offset) } @(objc_type=Heap, objc_name="newTextureWithDescriptor") @@ -6779,7 +6849,7 @@ Heap_newTextureWithDescriptor :: #force_inline proc(self: ^Heap, desc: ^TextureD return msgSend(^Heap, self, "newTextureWithDescriptor:", desc) } @(objc_type=Heap, objc_name="newTextureWithDescriptor_offset_") -Heap_newTextureWithDescriptor_offset_ :: #force_inline proc(self: ^Heap, descriptor: ^TextureDescriptor, offset: ^NS.Object) -> ^Heap { +Heap_newTextureWithDescriptor_offset_ :: #force_inline proc(self: ^Heap, descriptor: ^TextureDescriptor, offset: NS.UInteger) -> ^Heap { return msgSend(^Heap, self, "newTextureWithDescriptor:offset:", descriptor, offset) } @(objc_type=Heap, objc_name="resourceOptions") @@ -6795,8 +6865,8 @@ Heap_setPurgeableState :: #force_inline proc(self: ^Heap, state: PurgeableState) return msgSend(PurgeableState, self, "setPurgeableState:", state) } @(objc_type=Heap, objc_name="size") -Heap_size :: #force_inline proc(self: ^Heap) -> NS.Integer { - return msgSend(NS.Integer, self, "size") +Heap_size :: #force_inline proc(self: ^Heap) -> NS.UInteger { + return msgSend(NS.UInteger, self, "size") } @(objc_type=Heap, objc_name="storageMode") Heap_storageMode :: #force_inline proc(self: ^Heap) -> StorageMode { @@ -6807,8 +6877,8 @@ Heap_type :: #force_inline proc(self: ^Heap) -> FunctionLogType { return msgSend(FunctionLogType, self, "type") } @(objc_type=Heap, objc_name="usedSize") -Heap_usedSize :: #force_inline proc(self: ^Heap) -> NS.Integer { - return msgSend(NS.Integer, self, "usedSize") +Heap_usedSize :: #force_inline proc(self: ^Heap) -> NS.UInteger { + return msgSend(NS.UInteger, self, "usedSize") } //////////////////////////////////////////////////////////////////////////////// @@ -6824,14 +6894,14 @@ Methods: size */ @(objc_class="MTLIndirectCommandBuffer") -IndirectCommandBuffer :: struct { using _: NS.Object } +IndirectCommandBuffer :: struct { using _: Resource } @(objc_type=IndirectCommandBuffer, objc_name="indirectComputeCommandAtIndex") -IndirectCommandBuffer_indirectComputeCommandAtIndex :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: ^NS.Object) -> ^IndirectCommandBuffer { +IndirectCommandBuffer_indirectComputeCommandAtIndex :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: NS.UInteger) -> ^IndirectCommandBuffer { return msgSend(^IndirectCommandBuffer, self, "indirectComputeCommandAtIndex:", commandIndex) } @(objc_type=IndirectCommandBuffer, objc_name="indirectRenderCommandAtIndex") -IndirectCommandBuffer_indirectRenderCommandAtIndex :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: ^NS.Object) -> ^IndirectCommandBuffer { +IndirectCommandBuffer_indirectRenderCommandAtIndex :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: NS.UInteger) -> ^IndirectCommandBuffer { return msgSend(^IndirectCommandBuffer, self, "indirectRenderCommandAtIndex:", commandIndex) } @(objc_type=IndirectCommandBuffer, objc_name="resetWithRange") @@ -6839,8 +6909,8 @@ IndirectCommandBuffer_resetWithRange :: #force_inline proc(self: ^IndirectComman msgSend(nil, self, "resetWithRange:", range) } @(objc_type=IndirectCommandBuffer, objc_name="size") -IndirectCommandBuffer_size :: #force_inline proc(self: ^IndirectCommandBuffer) -> NS.Integer { - return msgSend(NS.Integer, self, "size") +IndirectCommandBuffer_size :: #force_inline proc(self: ^IndirectCommandBuffer) -> NS.UInteger { + return msgSend(NS.UInteger, self, "size") } //////////////////////////////////////////////////////////////////////////////// @@ -6885,15 +6955,15 @@ IndirectComputeCommand_setBarrier :: #force_inline proc(self: ^IndirectComputeCo msgSend(nil, self, "setBarrier") } @(objc_type=IndirectComputeCommand, objc_name="setComputePipelineState") -IndirectComputeCommand_setComputePipelineState :: #force_inline proc(self: ^IndirectComputeCommand, pipelineState: ^NS.Object) { +IndirectComputeCommand_setComputePipelineState :: #force_inline proc(self: ^IndirectComputeCommand, pipelineState: ^ComputePipelineState) { msgSend(nil, self, "setComputePipelineState:", pipelineState) } @(objc_type=IndirectComputeCommand, objc_name="setImageblockWidth") -IndirectComputeCommand_setImageblockWidth :: #force_inline proc(self: ^IndirectComputeCommand, width: ^NS.Object, height: ^NS.Object) { +IndirectComputeCommand_setImageblockWidth :: #force_inline proc(self: ^IndirectComputeCommand, width: NS.UInteger, height: NS.UInteger) { msgSend(nil, self, "setImageblockWidth:height:", width, height) } @(objc_type=IndirectComputeCommand, objc_name="setKernelBuffer") -IndirectComputeCommand_setKernelBuffer :: #force_inline proc(self: ^IndirectComputeCommand, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +IndirectComputeCommand_setKernelBuffer :: #force_inline proc(self: ^IndirectComputeCommand, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setKernelBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=IndirectComputeCommand, objc_name="setStageInRegion") @@ -6901,7 +6971,7 @@ IndirectComputeCommand_setStageInRegion :: #force_inline proc(self: ^IndirectCom msgSend(nil, self, "setStageInRegion:", region) } @(objc_type=IndirectComputeCommand, objc_name="setThreadgroupMemoryLength") -IndirectComputeCommand_setThreadgroupMemoryLength :: #force_inline proc(self: ^IndirectComputeCommand, length: ^NS.Object, index: ^NS.Object) { +IndirectComputeCommand_setThreadgroupMemoryLength :: #force_inline proc(self: ^IndirectComputeCommand, length: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setThreadgroupMemoryLength:atIndex:", length, index) } @@ -6925,19 +6995,19 @@ Methods: IndirectRenderCommand :: struct { using _: NS.Object } @(objc_type=IndirectRenderCommand, objc_name="drawIndexedPatches") -IndirectRenderCommand_drawIndexedPatches :: #force_inline proc(self: ^IndirectRenderCommand, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, controlPointIndexBuffer: ^NS.Object, controlPointIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object, buffer: ^NS.Object, offset: ^NS.Object, instanceStride: ^NS.Object) { +IndirectRenderCommand_drawIndexedPatches :: #force_inline proc(self: ^IndirectRenderCommand, numberOfPatchControlPoints: NS.UInteger, patchStart: NS.UInteger, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, controlPointIndexBuffer: ^Buffer, controlPointIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger, buffer: ^Buffer, offset: NS.UInteger, instanceStride: NS.UInteger) { msgSend(nil, self, "drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride) } @(objc_type=IndirectRenderCommand, objc_name="drawIndexedPrimitives") -IndirectRenderCommand_drawIndexedPrimitives :: #force_inline proc(self: ^IndirectRenderCommand, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseVertex: ^NS.Object, baseInstance: ^NS.Object) { +IndirectRenderCommand_drawIndexedPrimitives :: #force_inline proc(self: ^IndirectRenderCommand, primitiveType: PrimitiveType, indexCount: NS.UInteger, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseVertex: NS.Integer, baseInstance: NS.UInteger) { msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount, baseVertex, baseInstance) } @(objc_type=IndirectRenderCommand, objc_name="drawPatches") -IndirectRenderCommand_drawPatches :: #force_inline proc(self: ^IndirectRenderCommand, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object, buffer: ^NS.Object, offset: ^NS.Object, instanceStride: ^NS.Object) { +IndirectRenderCommand_drawPatches :: #force_inline proc(self: ^IndirectRenderCommand, numberOfPatchControlPoints: NS.UInteger, patchStart: NS.UInteger, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger, buffer: ^Buffer, offset: NS.UInteger, instanceStride: NS.UInteger) { msgSend(nil, self, "drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride) } @(objc_type=IndirectRenderCommand, objc_name="drawPrimitives") -IndirectRenderCommand_drawPrimitives :: #force_inline proc(self: ^IndirectRenderCommand, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) { +IndirectRenderCommand_drawPrimitives :: #force_inline proc(self: ^IndirectRenderCommand, 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=IndirectRenderCommand, objc_name="reset") @@ -6945,15 +7015,15 @@ IndirectRenderCommand_reset :: #force_inline proc(self: ^IndirectRenderCommand) msgSend(nil, self, "reset") } @(objc_type=IndirectRenderCommand, objc_name="setFragmentBuffer") -IndirectRenderCommand_setFragmentBuffer :: #force_inline proc(self: ^IndirectRenderCommand, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +IndirectRenderCommand_setFragmentBuffer :: #force_inline proc(self: ^IndirectRenderCommand, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setFragmentBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=IndirectRenderCommand, objc_name="setRenderPipelineState") -IndirectRenderCommand_setRenderPipelineState :: #force_inline proc(self: ^IndirectRenderCommand, pipelineState: ^NS.Object) { +IndirectRenderCommand_setRenderPipelineState :: #force_inline proc(self: ^IndirectRenderCommand, pipelineState: ^RenderPipelineState) { msgSend(nil, self, "setRenderPipelineState:", pipelineState) } @(objc_type=IndirectRenderCommand, objc_name="setVertexBuffer") -IndirectRenderCommand_setVertexBuffer :: #force_inline proc(self: ^IndirectRenderCommand, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +IndirectRenderCommand_setVertexBuffer :: #force_inline proc(self: ^IndirectRenderCommand, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setVertexBuffer:offset:atIndex:", buffer, offset, index) } @@ -6974,38 +7044,38 @@ Methods: setVisibleFunctionTables */ @(objc_class="MTLIntersectionFunctionTable") -IntersectionFunctionTable :: struct { using _: NS.Object } +IntersectionFunctionTable :: struct { using _: Resource } @(objc_type=IntersectionFunctionTable, objc_name="setBuffer") -IntersectionFunctionTable_setBuffer :: #force_inline proc(self: ^IntersectionFunctionTable, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +IntersectionFunctionTable_setBuffer :: #force_inline proc(self: ^IntersectionFunctionTable, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=IntersectionFunctionTable, objc_name="setBuffers") -IntersectionFunctionTable_setBuffers :: #force_inline proc(self: ^IntersectionFunctionTable, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { +IntersectionFunctionTable_setBuffers :: #force_inline proc(self: ^IntersectionFunctionTable, buffers: [^]^Buffer, offsets: [^]NS.UInteger, range: NS.Range) { msgSend(nil, self, "setBuffers:offsets:withRange:", buffers, offsets, range) } @(objc_type=IntersectionFunctionTable, objc_name="setFunction") -IntersectionFunctionTable_setFunction :: #force_inline proc(self: ^IntersectionFunctionTable, function: ^NS.Object, index: ^NS.Object) { +IntersectionFunctionTable_setFunction :: #force_inline proc(self: ^IntersectionFunctionTable, function: ^FunctionHandle, index: NS.UInteger) { msgSend(nil, self, "setFunction:atIndex:", function, index) } @(objc_type=IntersectionFunctionTable, objc_name="setFunctions") -IntersectionFunctionTable_setFunctions :: #force_inline proc(self: ^IntersectionFunctionTable, functions: ^^NS.Object, range: NS.Range) { +IntersectionFunctionTable_setFunctions :: #force_inline proc(self: ^IntersectionFunctionTable, functions: [^]^FunctionHandle, range: NS.Range) { msgSend(nil, self, "setFunctions:withRange:", functions, range) } -@(objc_type=IntersectionFunctionTable, objc_name="setOpaqueTriangleIntersectionFunctionWithSignature_atIndex_") -IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignature_atIndex_ :: #force_inline proc(self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, index: ^NS.Object) { +@(objc_type=IntersectionFunctionTable, objc_name="setOpaqueTriangleIntersectionFunctionWithSignatureAtIndex") +IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignatureAtIndex :: #force_inline proc(self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, index: NS.UInteger) { msgSend(nil, self, "setOpaqueTriangleIntersectionFunctionWithSignature:atIndex:", signature, index) } -@(objc_type=IntersectionFunctionTable, objc_name="setOpaqueTriangleIntersectionFunctionWithSignature_withRange_") -IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignature_withRange_ :: #force_inline proc(self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, range: NS.Range) { +@(objc_type=IntersectionFunctionTable, objc_name="setOpaqueTriangleIntersectionFunctionWithSignatureWithRange") +IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignatureWithRange :: #force_inline proc(self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, range: NS.Range) { msgSend(nil, self, "setOpaqueTriangleIntersectionFunctionWithSignature:withRange:", signature, range) } @(objc_type=IntersectionFunctionTable, objc_name="setVisibleFunctionTable") -IntersectionFunctionTable_setVisibleFunctionTable :: #force_inline proc(self: ^IntersectionFunctionTable, visibleFunctionTable: ^NS.Object, bufferIndex: ^NS.Object) { +IntersectionFunctionTable_setVisibleFunctionTable :: #force_inline proc(self: ^IntersectionFunctionTable, visibleFunctionTable: ^VisibleFunctionTable, bufferIndex: NS.UInteger) { msgSend(nil, self, "setVisibleFunctionTable:atBufferIndex:", visibleFunctionTable, bufferIndex) } @(objc_type=IntersectionFunctionTable, objc_name="setVisibleFunctionTables") -IntersectionFunctionTable_setVisibleFunctionTables :: #force_inline proc(self: ^IntersectionFunctionTable, visibleFunctionTables: ^^NS.Object, range: NS.Range) { +IntersectionFunctionTable_setVisibleFunctionTables :: #force_inline proc(self: ^IntersectionFunctionTable, visibleFunctionTables: [^]^VisibleFunctionTable, range: NS.Range) { msgSend(nil, self, "setVisibleFunctionTables:withBufferRange:", visibleFunctionTables, range) } @@ -7054,8 +7124,9 @@ Library_newFunctionWithDescriptor_completionHandler_ :: #force_inline proc(self: msgSend(nil, self, "newFunctionWithDescriptor:completionHandler:", descriptor, completionHandler) } @(objc_type=Library, objc_name="newFunctionWithDescriptor_error_") -Library_newFunctionWithDescriptor_error_ :: #force_inline proc(self: ^Library, descriptor: ^FunctionDescriptor, error: ^^NS.Error ) -> ^Library { - return msgSend(^Library, self, "newFunctionWithDescriptor:error:", descriptor, error) +Library_newFunctionWithDescriptor_error_ :: #force_inline proc(self: ^Library, descriptor: ^FunctionDescriptor) -> (library: ^Library, error: ^NS.Error) { + library = msgSend(^Library, self, "newFunctionWithDescriptor:error:", descriptor, &error) + return } @(objc_type=Library, objc_name="newFunctionWithName") Library_newFunctionWithName :: #force_inline proc(self: ^Library, functionName: ^NS.String) -> ^Library { @@ -7066,16 +7137,18 @@ Library_newFunctionWithName_constantValues_completionHandler_ :: #force_inline p msgSend(nil, self, "newFunctionWithName:constantValues:completionHandler:", name, constantValues, completionHandler) } @(objc_type=Library, objc_name="newFunctionWithName_constantValues_error_") -Library_newFunctionWithName_constantValues_error_ :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues, error: ^^NS.Error ) -> ^Library { - return msgSend(^Library, self, "newFunctionWithName:constantValues:error:", name, constantValues, error) +Library_newFunctionWithName_constantValues_error_ :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues) -> (library: ^Library, error: ^NS.Error) { + library = msgSend(^Library, self, "newFunctionWithName:constantValues:error:", name, constantValues, &error) + return } @(objc_type=Library, objc_name="newIntersectionFunctionWithDescriptor_completionHandler_") Library_newIntersectionFunctionWithDescriptor_completionHandler_ :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor, completionHandler: rawptr) { msgSend(nil, self, "newIntersectionFunctionWithDescriptor:completionHandler:", descriptor, completionHandler) } @(objc_type=Library, objc_name="newIntersectionFunctionWithDescriptor_error_") -Library_newIntersectionFunctionWithDescriptor_error_ :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor, error: ^^NS.Error ) -> ^Library { - return msgSend(^Library, self, "newIntersectionFunctionWithDescriptor:error:", descriptor, error) +Library_newIntersectionFunctionWithDescriptor_error_ :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor) -> (library: ^Library, error: ^NS.Error) { + library = msgSend(^Library, self, "newIntersectionFunctionWithDescriptor:error:", descriptor, &error) + return } @(objc_type=Library, objc_name="setLabel") Library_setLabel :: #force_inline proc(self: ^Library, label: ^NS.String) { @@ -7109,11 +7182,11 @@ ParallelRenderCommandEncoder_renderCommandEncoder :: #force_inline proc(self: ^P return msgSend(^ParallelRenderCommandEncoder, self, "renderCommandEncoder") } @(objc_type=ParallelRenderCommandEncoder, objc_name="setColorStoreAction") -ParallelRenderCommandEncoder_setColorStoreAction :: #force_inline proc(self: ^ParallelRenderCommandEncoder, storeAction: StoreAction, colorAttachmentIndex: ^NS.Object) { +ParallelRenderCommandEncoder_setColorStoreAction :: #force_inline proc(self: ^ParallelRenderCommandEncoder, storeAction: StoreAction, colorAttachmentIndex: NS.UInteger) { msgSend(nil, self, "setColorStoreAction:atIndex:", storeAction, colorAttachmentIndex) } @(objc_type=ParallelRenderCommandEncoder, objc_name="setColorStoreActionOptions") -ParallelRenderCommandEncoder_setColorStoreActionOptions :: #force_inline proc(self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions, colorAttachmentIndex: ^NS.Object) { +ParallelRenderCommandEncoder_setColorStoreActionOptions :: #force_inline proc(self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions, colorAttachmentIndex: NS.UInteger) { msgSend(nil, self, "setColorStoreActionOptions:atIndex:", storeActionOptions, colorAttachmentIndex) } @(objc_type=ParallelRenderCommandEncoder, objc_name="setDepthStoreAction") @@ -7155,7 +7228,7 @@ Methods: RasterizationRateMap :: struct { using _: NS.Object } @(objc_type=RasterizationRateMap, objc_name="copyParameterDataToBuffer") -RasterizationRateMap_copyParameterDataToBuffer :: #force_inline proc(self: ^RasterizationRateMap, buffer: ^NS.Object, offset: ^NS.Object) { +RasterizationRateMap_copyParameterDataToBuffer :: #force_inline proc(self: ^RasterizationRateMap, buffer: ^Buffer, offset: NS.UInteger) { msgSend(nil, self, "copyParameterDataToBuffer:offset:", buffer, offset) } @(objc_type=RasterizationRateMap, objc_name="device") @@ -7167,15 +7240,15 @@ RasterizationRateMap_label :: #force_inline proc(self: ^RasterizationRateMap) -> return msgSend(^NS.String, self, "label") } @(objc_type=RasterizationRateMap, objc_name="layerCount") -RasterizationRateMap_layerCount :: #force_inline proc(self: ^RasterizationRateMap) -> NS.Integer { - return msgSend(NS.Integer, self, "layerCount") +RasterizationRateMap_layerCount :: #force_inline proc(self: ^RasterizationRateMap) -> NS.UInteger { + return msgSend(NS.UInteger, self, "layerCount") } @(objc_type=RasterizationRateMap, objc_name="mapPhysicalToScreenCoordinates") -RasterizationRateMap_mapPhysicalToScreenCoordinates :: #force_inline proc(self: ^RasterizationRateMap, physicalCoordinates: Coordinate2D, layerIndex: ^NS.Object) -> Coordinate2D { +RasterizationRateMap_mapPhysicalToScreenCoordinates :: #force_inline proc(self: ^RasterizationRateMap, physicalCoordinates: Coordinate2D, layerIndex: NS.UInteger) -> Coordinate2D { return msgSend(Coordinate2D, self, "mapPhysicalToScreenCoordinates:forLayer:", physicalCoordinates, layerIndex) } @(objc_type=RasterizationRateMap, objc_name="mapScreenToPhysicalCoordinates") -RasterizationRateMap_mapScreenToPhysicalCoordinates :: #force_inline proc(self: ^RasterizationRateMap, screenCoordinates: Coordinate2D, layerIndex: ^NS.Object) -> Coordinate2D { +RasterizationRateMap_mapScreenToPhysicalCoordinates :: #force_inline proc(self: ^RasterizationRateMap, screenCoordinates: Coordinate2D, layerIndex: NS.UInteger) -> Coordinate2D { return msgSend(Coordinate2D, self, "mapScreenToPhysicalCoordinates:forLayer:", screenCoordinates, layerIndex) } @(objc_type=RasterizationRateMap, objc_name="parameterBufferSizeAndAlign") @@ -7187,7 +7260,7 @@ RasterizationRateMap_physicalGranularity :: #force_inline proc(self: ^Rasterizat return msgSend(Size, self, "physicalGranularity") } @(objc_type=RasterizationRateMap, objc_name="physicalSizeForLayer") -RasterizationRateMap_physicalSizeForLayer :: #force_inline proc(self: ^RasterizationRateMap, layerIndex: ^NS.Object) -> Size { +RasterizationRateMap_physicalSizeForLayer :: #force_inline proc(self: ^RasterizationRateMap, layerIndex: NS.UInteger) -> Size { return msgSend(Size, self, "physicalSizeForLayer:", layerIndex) } @(objc_type=RasterizationRateMap, objc_name="screenSize") @@ -7297,63 +7370,63 @@ RenderCommandEncoder_dispatchThreadsPerTile :: #force_inline proc(self: ^RenderC msgSend(nil, self, "dispatchThreadsPerTile:", threadsPerTile) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexedPatches_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_indirectBuffer_indirectBufferOffset_") -RenderCommandEncoder_drawIndexedPatches_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, controlPointIndexBuffer: ^NS.Object, controlPointIndexBufferOffset: ^NS.Object, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { +RenderCommandEncoder_drawIndexedPatches_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, controlPointIndexBuffer: ^Buffer, controlPointIndexBufferOffset: NS.UInteger, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "drawIndexedPatches:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:indirectBuffer:indirectBufferOffset:", numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, indirectBuffer, indirectBufferOffset) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_") -RenderCommandEncoder_drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, controlPointIndexBuffer: ^NS.Object, controlPointIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) { +RenderCommandEncoder_drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchStart: NS.UInteger, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, controlPointIndexBuffer: ^Buffer, controlPointIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) { msgSend(nil, self, "drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, instanceCount, baseInstance) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_") -RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object) { +RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: NS.UInteger, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger) { msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_") -RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, instanceCount: ^NS.Object) { +RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: NS.UInteger, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger, instanceCount: NS.UInteger) { msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_") -RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseVertex: ^NS.Object, baseInstance: ^NS.Object) { +RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: NS.UInteger, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseVertex: NS.Integer, baseInstance: NS.UInteger) { msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount, baseVertex, baseInstance) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexType_indexBuffer_indexBufferOffset_indirectBuffer_indirectBufferOffset_") -RenderCommandEncoder_drawIndexedPrimitives_indexType_indexBuffer_indexBufferOffset_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { +RenderCommandEncoder_drawIndexedPrimitives_indexType_indexBuffer_indexBufferOffset_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "drawIndexedPrimitives:indexType:indexBuffer:indexBufferOffset:indirectBuffer:indirectBufferOffset:", primitiveType, indexType, indexBuffer, indexBufferOffset, indirectBuffer, indirectBufferOffset) } @(objc_type=RenderCommandEncoder, objc_name="drawPatches_patchIndexBuffer_patchIndexBufferOffset_indirectBuffer_indirectBufferOffset_") -RenderCommandEncoder_drawPatches_patchIndexBuffer_patchIndexBufferOffset_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { +RenderCommandEncoder_drawPatches_patchIndexBuffer_patchIndexBufferOffset_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "drawPatches:patchIndexBuffer:patchIndexBufferOffset:indirectBuffer:indirectBufferOffset:", numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, indirectBuffer, indirectBufferOffset) } @(objc_type=RenderCommandEncoder, objc_name="drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_") -RenderCommandEncoder_drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) { +RenderCommandEncoder_drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchStart: NS.UInteger, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) { msgSend(nil, self, "drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance) } @(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_indirectBuffer_indirectBufferOffset_") -RenderCommandEncoder_drawPrimitives_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { +RenderCommandEncoder_drawPrimitives_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "drawPrimitives:indirectBuffer:indirectBufferOffset:", primitiveType, indirectBuffer, indirectBufferOffset) } @(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_vertexStart_vertexCount_") -RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object) { +RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger) { msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:", primitiveType, vertexStart, vertexCount) } @(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_vertexStart_vertexCount_instanceCount_") -RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_instanceCount_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object, instanceCount: ^NS.Object) { +RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_instanceCount_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger, instanceCount: NS.UInteger) { msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:instanceCount:", primitiveType, vertexStart, vertexCount, instanceCount) } @(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_") -RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) { +RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_ :: #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_indirectBuffer_indirectBufferOffset_") -RenderCommandEncoder_executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, indirectCommandbuffer: ^NS.Object, indirectRangeBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { +@(objc_type=RenderCommandEncoder, objc_name="executeCommandsInBuffer") +RenderCommandEncoder_executeCommandsInBuffer :: #force_inline proc(self: ^RenderCommandEncoder, indirectCommandbuffer: ^Buffer, indirectRangeBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "executeCommandsInBuffer:indirectBuffer:indirectBufferOffset:", indirectCommandbuffer, indirectRangeBuffer, indirectBufferOffset) } -@(objc_type=RenderCommandEncoder, objc_name="executeCommandsInBuffer_withRange_") -RenderCommandEncoder_executeCommandsInBuffer_withRange_ :: #force_inline proc(self: ^RenderCommandEncoder, indirectCommandBuffer: ^NS.Object, executionRange: NS.Range) { +@(objc_type=RenderCommandEncoder, objc_name="executeCommandsInBufferWithRange") +RenderCommandEncoder_executeCommandsInBufferWithRange :: #force_inline proc(self: ^RenderCommandEncoder, indirectCommandBuffer: ^Buffer, executionRange: NS.Range) { msgSend(nil, self, "executeCommandsInBuffer:withRange:", indirectCommandBuffer, executionRange) } @(objc_type=RenderCommandEncoder, objc_name="memoryBarrierWithResources") -RenderCommandEncoder_memoryBarrierWithResources :: #force_inline proc(self: ^RenderCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, after: RenderStages, before: RenderStages) { +RenderCommandEncoder_memoryBarrierWithResources :: #force_inline proc(self: ^RenderCommandEncoder, resources: [^]^Resource, count: NS.UInteger, after: RenderStages, before: RenderStages) { msgSend(nil, self, "memoryBarrierWithResources:count:afterStages:beforeStages:", resources, count, after, before) } @(objc_type=RenderCommandEncoder, objc_name="memoryBarrierWithScope") @@ -7361,7 +7434,7 @@ RenderCommandEncoder_memoryBarrierWithScope :: #force_inline proc(self: ^RenderC msgSend(nil, self, "memoryBarrierWithScope:afterStages:beforeStages:", scope, after, before) } @(objc_type=RenderCommandEncoder, objc_name="sampleCountersInBuffer") -RenderCommandEncoder_sampleCountersInBuffer :: #force_inline proc(self: ^RenderCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) { +RenderCommandEncoder_sampleCountersInBuffer :: #force_inline proc(self: ^RenderCommandEncoder, sampleBuffer: ^Buffer, sampleIndex: NS.UInteger, barrier: BOOL) { msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier) } @(objc_type=RenderCommandEncoder, objc_name="setBlendColorRed") @@ -7369,11 +7442,11 @@ RenderCommandEncoder_setBlendColorRed :: #force_inline proc(self: ^RenderCommand msgSend(nil, self, "setBlendColorRed:green:blue:alpha:", red, green, blue, alpha) } @(objc_type=RenderCommandEncoder, objc_name="setColorStoreAction") -RenderCommandEncoder_setColorStoreAction :: #force_inline proc(self: ^RenderCommandEncoder, storeAction: StoreAction, colorAttachmentIndex: ^NS.Object) { +RenderCommandEncoder_setColorStoreAction :: #force_inline proc(self: ^RenderCommandEncoder, storeAction: StoreAction, colorAttachmentIndex: NS.UInteger) { msgSend(nil, self, "setColorStoreAction:atIndex:", storeAction, colorAttachmentIndex) } @(objc_type=RenderCommandEncoder, objc_name="setColorStoreActionOptions") -RenderCommandEncoder_setColorStoreActionOptions :: #force_inline proc(self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions, colorAttachmentIndex: ^NS.Object) { +RenderCommandEncoder_setColorStoreActionOptions :: #force_inline proc(self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions, colorAttachmentIndex: NS.UInteger) { msgSend(nil, self, "setColorStoreActionOptions:atIndex:", storeActionOptions, colorAttachmentIndex) } @(objc_type=RenderCommandEncoder, objc_name="setCullMode") @@ -7389,7 +7462,7 @@ RenderCommandEncoder_setDepthClipMode :: #force_inline proc(self: ^RenderCommand msgSend(nil, self, "setDepthClipMode:", depthClipMode) } @(objc_type=RenderCommandEncoder, objc_name="setDepthStencilState") -RenderCommandEncoder_setDepthStencilState :: #force_inline proc(self: ^RenderCommandEncoder, depthStencilState: ^NS.Object) { +RenderCommandEncoder_setDepthStencilState :: #force_inline proc(self: ^RenderCommandEncoder, depthStencilState: ^DepthStencilState) { msgSend(nil, self, "setDepthStencilState:", depthStencilState) } @(objc_type=RenderCommandEncoder, objc_name="setDepthStoreAction") @@ -7401,43 +7474,43 @@ RenderCommandEncoder_setDepthStoreActionOptions :: #force_inline proc(self: ^Ren msgSend(nil, self, "setDepthStoreActionOptions:", storeActionOptions) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentBuffer") -RenderCommandEncoder_setFragmentBuffer :: #force_inline proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setFragmentBuffer :: #force_inline proc(self: ^RenderCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setFragmentBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentBufferOffset") -RenderCommandEncoder_setFragmentBufferOffset :: #force_inline proc(self: ^RenderCommandEncoder, offset: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setFragmentBufferOffset :: #force_inline proc(self: ^RenderCommandEncoder, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setFragmentBufferOffset:atIndex:", offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentBuffers") -RenderCommandEncoder_setFragmentBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { +RenderCommandEncoder_setFragmentBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: [^]^Buffer, offsets: [^]NS.UInteger, range: NS.Range) { msgSend(nil, self, "setFragmentBuffers:offsets:withRange:", buffers, offsets, range) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentBytes") -RenderCommandEncoder_setFragmentBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setFragmentBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: rawptr, length: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setFragmentBytes:length:atIndex:", bytes, length, index) } -@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerState_atIndex_") -RenderCommandEncoder_setFragmentSamplerState_atIndex_ :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) { +@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStateAtIndex") +RenderCommandEncoder_setFragmentSamplerStateAtIndex :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { msgSend(nil, self, "setFragmentSamplerState:atIndex:", sampler, index) } -@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerState_lodMinClamp_lodMaxClamp_atIndex_") -RenderCommandEncoder_setFragmentSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) { +@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerState_lodMinClamp_lodMaxClampAtIndex") +RenderCommandEncoder_setFragmentSamplerState_lodMinClamp_lodMaxClampAtIndex :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { msgSend(nil, self, "setFragmentSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } -@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStates_lodMinClamps_lodMaxClamps_withRange_") -RenderCommandEncoder_setFragmentSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: #force_inline proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { +@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStates_lodMinClamps_lodMaxClampsWithRange") +RenderCommandEncoder_setFragmentSamplerStates_lodMinClamps_lodMaxClampsWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: [^]^SamplerState, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { msgSend(nil, self, "setFragmentSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range) } -@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStates_withRange_") -RenderCommandEncoder_setFragmentSamplerStates_withRange_ :: #force_inline proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, range: NS.Range) { +@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStatesWithRange") +RenderCommandEncoder_setFragmentSamplerStatesWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: [^]^SamplerState, range: NS.Range) { msgSend(nil, self, "setFragmentSamplerStates:withRange:", samplers, range) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentTexture") -RenderCommandEncoder_setFragmentTexture :: #force_inline proc(self: ^RenderCommandEncoder, texture: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setFragmentTexture :: #force_inline proc(self: ^RenderCommandEncoder, texture: ^Texture, index: NS.UInteger) { msgSend(nil, self, "setFragmentTexture:atIndex:", texture, index) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentTextures") -RenderCommandEncoder_setFragmentTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: ^^NS.Object, range: NS.Range) { +RenderCommandEncoder_setFragmentTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: [^]^Texture, range: NS.Range) { msgSend(nil, self, "setFragmentTextures:withRange:", textures, range) } @(objc_type=RenderCommandEncoder, objc_name="setFrontFacingWinding") @@ -7445,7 +7518,7 @@ RenderCommandEncoder_setFrontFacingWinding :: #force_inline proc(self: ^RenderCo msgSend(nil, self, "setFrontFacingWinding:", frontFacingWinding) } @(objc_type=RenderCommandEncoder, objc_name="setRenderPipelineState") -RenderCommandEncoder_setRenderPipelineState :: #force_inline proc(self: ^RenderCommandEncoder, pipelineState: ^NS.Object) { +RenderCommandEncoder_setRenderPipelineState :: #force_inline proc(self: ^RenderCommandEncoder, pipelineState: ^RenderPipelineState) { msgSend(nil, self, "setRenderPipelineState:", pipelineState) } @(objc_type=RenderCommandEncoder, objc_name="setScissorRect") @@ -7453,7 +7526,7 @@ RenderCommandEncoder_setScissorRect :: #force_inline proc(self: ^RenderCommandEn msgSend(nil, self, "setScissorRect:", rect) } @(objc_type=RenderCommandEncoder, objc_name="setScissorRects") -RenderCommandEncoder_setScissorRects :: #force_inline proc(self: ^RenderCommandEncoder, scissorRects: ^ScissorRect, count: ^NS.Object) { +RenderCommandEncoder_setScissorRects :: #force_inline proc(self: ^RenderCommandEncoder, scissorRects: ^ScissorRect, count: NS.UInteger) { msgSend(nil, self, "setScissorRects:count:", scissorRects, count) } @(objc_type=RenderCommandEncoder, objc_name="setStencilFrontReferenceValue") @@ -7473,7 +7546,7 @@ RenderCommandEncoder_setStencilStoreActionOptions :: #force_inline proc(self: ^R msgSend(nil, self, "setStencilStoreActionOptions:", storeActionOptions) } @(objc_type=RenderCommandEncoder, objc_name="setTessellationFactorBuffer") -RenderCommandEncoder_setTessellationFactorBuffer :: #force_inline proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, instanceStride: ^NS.Object) { +RenderCommandEncoder_setTessellationFactorBuffer :: #force_inline proc(self: ^RenderCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, instanceStride: NS.UInteger) { msgSend(nil, self, "setTessellationFactorBuffer:offset:instanceStride:", buffer, offset, instanceStride) } @(objc_type=RenderCommandEncoder, objc_name="setTessellationFactorScale") @@ -7481,47 +7554,47 @@ RenderCommandEncoder_setTessellationFactorScale :: #force_inline proc(self: ^Ren msgSend(nil, self, "setTessellationFactorScale:", scale) } @(objc_type=RenderCommandEncoder, objc_name="setThreadgroupMemoryLength") -RenderCommandEncoder_setThreadgroupMemoryLength :: #force_inline proc(self: ^RenderCommandEncoder, length: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setThreadgroupMemoryLength :: #force_inline proc(self: ^RenderCommandEncoder, length: NS.UInteger, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setThreadgroupMemoryLength:offset:atIndex:", length, offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setTileBuffer") -RenderCommandEncoder_setTileBuffer :: #force_inline proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setTileBuffer :: #force_inline proc(self: ^RenderCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setTileBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setTileBufferOffset") -RenderCommandEncoder_setTileBufferOffset :: #force_inline proc(self: ^RenderCommandEncoder, offset: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setTileBufferOffset :: #force_inline proc(self: ^RenderCommandEncoder, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setTileBufferOffset:atIndex:", offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setTileBuffers") -RenderCommandEncoder_setTileBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { +RenderCommandEncoder_setTileBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: [^]^Buffer, offsets: [^]NS.UInteger, range: NS.Range) { msgSend(nil, self, "setTileBuffers:offsets:withRange:", buffers, offsets, range) } @(objc_type=RenderCommandEncoder, objc_name="setTileBytes") -RenderCommandEncoder_setTileBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setTileBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: rawptr, length: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setTileBytes:length:atIndex:", bytes, length, index) } -@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerState_atIndex_") -RenderCommandEncoder_setTileSamplerState_atIndex_ :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) { +@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerStateAtIndex") +RenderCommandEncoder_setTileSamplerStateAtIndex :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { msgSend(nil, self, "setTileSamplerState:atIndex:", sampler, index) } -@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerState_lodMinClamp_lodMaxClamp_atIndex_") -RenderCommandEncoder_setTileSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) { +@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerState_lodMinClamp_lodMaxClampAtIndex") +RenderCommandEncoder_setTileSamplerState_lodMinClamp_lodMaxClampAtIndex :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { msgSend(nil, self, "setTileSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } -@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerStates_lodMinClamps_lodMaxClamps_withRange_") -RenderCommandEncoder_setTileSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: #force_inline proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { +@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerStates_lodMinClamps_lodMaxClampsWithRange") +RenderCommandEncoder_setTileSamplerStates_lodMinClamps_lodMaxClampsWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: [^]^SamplerState, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { msgSend(nil, self, "setTileSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range) } -@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerStates_withRange_") -RenderCommandEncoder_setTileSamplerStates_withRange_ :: #force_inline proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, range: NS.Range) { +@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerStatesWithRange") +RenderCommandEncoder_setTileSamplerStatesWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: [^]^SamplerState, range: NS.Range) { msgSend(nil, self, "setTileSamplerStates:withRange:", samplers, range) } @(objc_type=RenderCommandEncoder, objc_name="setTileTexture") -RenderCommandEncoder_setTileTexture :: #force_inline proc(self: ^RenderCommandEncoder, texture: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setTileTexture :: #force_inline proc(self: ^RenderCommandEncoder, texture: ^Texture, index: NS.UInteger) { msgSend(nil, self, "setTileTexture:atIndex:", texture, index) } @(objc_type=RenderCommandEncoder, objc_name="setTileTextures") -RenderCommandEncoder_setTileTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: ^^NS.Object, range: NS.Range) { +RenderCommandEncoder_setTileTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: [^]^Texture, range: NS.Range) { msgSend(nil, self, "setTileTextures:withRange:", textures, range) } @(objc_type=RenderCommandEncoder, objc_name="setTriangleFillMode") @@ -7529,47 +7602,47 @@ RenderCommandEncoder_setTriangleFillMode :: #force_inline proc(self: ^RenderComm msgSend(nil, self, "setTriangleFillMode:", fillMode) } @(objc_type=RenderCommandEncoder, objc_name="setVertexAmplificationCount") -RenderCommandEncoder_setVertexAmplificationCount :: #force_inline proc(self: ^RenderCommandEncoder, count: ^NS.Object, viewMappings: ^VertexAmplificationViewMapping) { +RenderCommandEncoder_setVertexAmplificationCount :: #force_inline proc(self: ^RenderCommandEncoder, count: NS.UInteger, viewMappings: ^VertexAmplificationViewMapping) { msgSend(nil, self, "setVertexAmplificationCount:viewMappings:", count, viewMappings) } @(objc_type=RenderCommandEncoder, objc_name="setVertexBuffer") -RenderCommandEncoder_setVertexBuffer :: #force_inline proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setVertexBuffer :: #force_inline proc(self: ^RenderCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setVertexBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setVertexBufferOffset") -RenderCommandEncoder_setVertexBufferOffset :: #force_inline proc(self: ^RenderCommandEncoder, offset: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setVertexBufferOffset :: #force_inline proc(self: ^RenderCommandEncoder, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setVertexBufferOffset:atIndex:", offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setVertexBuffers") -RenderCommandEncoder_setVertexBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) { +RenderCommandEncoder_setVertexBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: [^]^Buffer, offsets: [^]NS.UInteger, range: NS.Range) { msgSend(nil, self, "setVertexBuffers:offsets:withRange:", buffers, offsets, range) } @(objc_type=RenderCommandEncoder, objc_name="setVertexBytes") -RenderCommandEncoder_setVertexBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setVertexBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: rawptr, length: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setVertexBytes:length:atIndex:", bytes, length, index) } -@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerState_atIndex_") -RenderCommandEncoder_setVertexSamplerState_atIndex_ :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) { +@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerStateAtIndex") +RenderCommandEncoder_setVertexSamplerStateAtIndex :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { msgSend(nil, self, "setVertexSamplerState:atIndex:", sampler, index) } -@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerState_lodMinClamp_lodMaxClamp_atIndex_") -RenderCommandEncoder_setVertexSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) { +@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerState_lodMinClamp_lodMaxClampAtIndex") +RenderCommandEncoder_setVertexSamplerState_lodMinClamp_lodMaxClampAtIndex :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { msgSend(nil, self, "setVertexSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } -@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerStates_lodMinClamps_lodMaxClamps_withRange_") -RenderCommandEncoder_setVertexSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: #force_inline proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { +@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerStates_lodMinClamps_lodMaxClampsWithRange") +RenderCommandEncoder_setVertexSamplerStates_lodMinClamps_lodMaxClampsWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: [^]^SamplerState, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { msgSend(nil, self, "setVertexSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range) } -@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerStates_withRange_") -RenderCommandEncoder_setVertexSamplerStates_withRange_ :: #force_inline proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, range: NS.Range) { +@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerStatesWithRange") +RenderCommandEncoder_setVertexSamplerStatesWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: [^]^SamplerState, range: NS.Range) { msgSend(nil, self, "setVertexSamplerStates:withRange:", samplers, range) } @(objc_type=RenderCommandEncoder, objc_name="setVertexTexture") -RenderCommandEncoder_setVertexTexture :: #force_inline proc(self: ^RenderCommandEncoder, texture: ^NS.Object, index: ^NS.Object) { +RenderCommandEncoder_setVertexTexture :: #force_inline proc(self: ^RenderCommandEncoder, texture: ^Texture, index: NS.UInteger) { msgSend(nil, self, "setVertexTexture:atIndex:", texture, index) } @(objc_type=RenderCommandEncoder, objc_name="setVertexTextures") -RenderCommandEncoder_setVertexTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: ^^NS.Object, range: NS.Range) { +RenderCommandEncoder_setVertexTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: [^]^Texture, range: NS.Range) { msgSend(nil, self, "setVertexTextures:withRange:", textures, range) } @(objc_type=RenderCommandEncoder, objc_name="setViewport") @@ -7577,11 +7650,11 @@ RenderCommandEncoder_setViewport :: #force_inline proc(self: ^RenderCommandEncod msgSend(nil, self, "setViewport:", viewport) } @(objc_type=RenderCommandEncoder, objc_name="setViewports") -RenderCommandEncoder_setViewports :: #force_inline proc(self: ^RenderCommandEncoder, viewports: ^Viewport, count: ^NS.Object) { +RenderCommandEncoder_setViewports :: #force_inline proc(self: ^RenderCommandEncoder, viewports: ^Viewport, count: NS.UInteger) { msgSend(nil, self, "setViewports:count:", viewports, count) } @(objc_type=RenderCommandEncoder, objc_name="setVisibilityResultMode") -RenderCommandEncoder_setVisibilityResultMode :: #force_inline proc(self: ^RenderCommandEncoder, mode: VisibilityResultMode, offset: ^NS.Object) { +RenderCommandEncoder_setVisibilityResultMode :: #force_inline proc(self: ^RenderCommandEncoder, mode: VisibilityResultMode, offset: NS.UInteger) { msgSend(nil, self, "setVisibilityResultMode:offset:", mode, offset) } @(objc_type=RenderCommandEncoder, objc_name="textureBarrier") @@ -7589,51 +7662,51 @@ RenderCommandEncoder_textureBarrier :: #force_inline proc(self: ^RenderCommandEn msgSend(nil, self, "textureBarrier") } @(objc_type=RenderCommandEncoder, objc_name="tileHeight") -RenderCommandEncoder_tileHeight :: #force_inline proc(self: ^RenderCommandEncoder) -> NS.Integer { - return msgSend(NS.Integer, self, "tileHeight") +RenderCommandEncoder_tileHeight :: #force_inline proc(self: ^RenderCommandEncoder) -> NS.UInteger { + return msgSend(NS.UInteger, self, "tileHeight") } @(objc_type=RenderCommandEncoder, objc_name="tileWidth") -RenderCommandEncoder_tileWidth :: #force_inline proc(self: ^RenderCommandEncoder) -> NS.Integer { - return msgSend(NS.Integer, self, "tileWidth") +RenderCommandEncoder_tileWidth :: #force_inline proc(self: ^RenderCommandEncoder) -> NS.UInteger { + return msgSend(NS.UInteger, self, "tileWidth") } @(objc_type=RenderCommandEncoder, objc_name="updateFence") -RenderCommandEncoder_updateFence :: #force_inline proc(self: ^RenderCommandEncoder, fence: ^NS.Object, stages: RenderStages) { +RenderCommandEncoder_updateFence :: #force_inline proc(self: ^RenderCommandEncoder, fence: ^Fence, stages: RenderStages) { msgSend(nil, self, "updateFence:afterStages:", fence, stages) } @(objc_type=RenderCommandEncoder, objc_name="useHeap") -RenderCommandEncoder_useHeap :: #force_inline proc(self: ^RenderCommandEncoder, heap: ^NS.Object) { +RenderCommandEncoder_useHeap :: #force_inline proc(self: ^RenderCommandEncoder, heap: ^Heap) { msgSend(nil, self, "useHeap:", heap) } @(objc_type=RenderCommandEncoder, objc_name="useHeap_stages_") -RenderCommandEncoder_useHeap_stages_ :: #force_inline proc(self: ^RenderCommandEncoder, heap: ^NS.Object, stages: RenderStages) { +RenderCommandEncoder_useHeap_stages_ :: #force_inline proc(self: ^RenderCommandEncoder, heap: ^Heap, stages: RenderStages) { msgSend(nil, self, "useHeap:stages:", heap, stages) } @(objc_type=RenderCommandEncoder, objc_name="useHeaps") -RenderCommandEncoder_useHeaps :: #force_inline proc(self: ^RenderCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object) { +RenderCommandEncoder_useHeaps :: #force_inline proc(self: ^RenderCommandEncoder, heaps: [^]^Heap, count: NS.UInteger) { msgSend(nil, self, "useHeaps:count:", heaps, count) } @(objc_type=RenderCommandEncoder, objc_name="useHeaps_count_stages_") -RenderCommandEncoder_useHeaps_count_stages_ :: #force_inline proc(self: ^RenderCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object, stages: RenderStages) { +RenderCommandEncoder_useHeaps_count_stages_ :: #force_inline proc(self: ^RenderCommandEncoder, heaps: [^]^Heap, count: NS.UInteger, stages: RenderStages) { msgSend(nil, self, "useHeaps:count:stages:", heaps, count, stages) } @(objc_type=RenderCommandEncoder, objc_name="useResource") -RenderCommandEncoder_useResource :: #force_inline proc(self: ^RenderCommandEncoder, resource: ^NS.Object, usage: ResourceUsage) { +RenderCommandEncoder_useResource :: #force_inline proc(self: ^RenderCommandEncoder, resource: ^Resource, usage: ResourceUsage) { msgSend(nil, self, "useResource:usage:", resource, usage) } @(objc_type=RenderCommandEncoder, objc_name="useResource_usage_stages_") -RenderCommandEncoder_useResource_usage_stages_ :: #force_inline proc(self: ^RenderCommandEncoder, resource: ^NS.Object, usage: ResourceUsage, stages: RenderStages) { +RenderCommandEncoder_useResource_usage_stages_ :: #force_inline proc(self: ^RenderCommandEncoder, resource: ^Resource, usage: ResourceUsage, stages: RenderStages) { msgSend(nil, self, "useResource:usage:stages:", resource, usage, stages) } @(objc_type=RenderCommandEncoder, objc_name="useResources") -RenderCommandEncoder_useResources :: #force_inline proc(self: ^RenderCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage) { +RenderCommandEncoder_useResources :: #force_inline proc(self: ^RenderCommandEncoder, resources: [^]^Resource, count: NS.UInteger, usage: ResourceUsage) { msgSend(nil, self, "useResources:count:usage:", resources, count, usage) } @(objc_type=RenderCommandEncoder, objc_name="useResources_count_usage_stages_") -RenderCommandEncoder_useResources_count_usage_stages_ :: #force_inline proc(self: ^RenderCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage, stages: RenderStages) { +RenderCommandEncoder_useResources_count_usage_stages_ :: #force_inline proc(self: ^RenderCommandEncoder, resources: [^]^Resource, count: NS.UInteger, usage: ResourceUsage, stages: RenderStages) { msgSend(nil, self, "useResources:count:usage:stages:", resources, count, usage, stages) } @(objc_type=RenderCommandEncoder, objc_name="waitForFence") -RenderCommandEncoder_waitForFence :: #force_inline proc(self: ^RenderCommandEncoder, fence: ^NS.Object, stages: RenderStages) { +RenderCommandEncoder_waitForFence :: #force_inline proc(self: ^RenderCommandEncoder, fence: ^Fence, stages: RenderStages) { msgSend(nil, self, "waitForFence:beforeStages:", fence, stages) } @@ -7664,16 +7737,16 @@ RenderPipelineState_imageblockMemoryLengthForDimensions :: #force_inline proc(se return msgSend(^RenderPipelineState, self, "imageblockMemoryLengthForDimensions:", imageblockDimensions) } @(objc_type=RenderPipelineState, objc_name="imageblockSampleLength") -RenderPipelineState_imageblockSampleLength :: #force_inline proc(self: ^RenderPipelineState) -> NS.Integer { - return msgSend(NS.Integer, self, "imageblockSampleLength") +RenderPipelineState_imageblockSampleLength :: #force_inline proc(self: ^RenderPipelineState) -> NS.UInteger { + return msgSend(NS.UInteger, self, "imageblockSampleLength") } @(objc_type=RenderPipelineState, objc_name="label") RenderPipelineState_label :: #force_inline proc(self: ^RenderPipelineState) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=RenderPipelineState, objc_name="maxTotalThreadsPerThreadgroup") -RenderPipelineState_maxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^RenderPipelineState) -> NS.Integer { - return msgSend(NS.Integer, self, "maxTotalThreadsPerThreadgroup") +RenderPipelineState_maxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^RenderPipelineState) -> NS.UInteger { + return msgSend(NS.UInteger, self, "maxTotalThreadsPerThreadgroup") } @(objc_type=RenderPipelineState, objc_name="supportIndirectCommandBuffers") RenderPipelineState_supportIndirectCommandBuffers :: #force_inline proc(self: ^RenderPipelineState) -> BOOL { @@ -7709,8 +7782,8 @@ Methods: Resource :: struct { using _: NS.Object } @(objc_type=Resource, objc_name="allocatedSize") -Resource_allocatedSize :: #force_inline proc(self: ^Resource) -> NS.Integer { - return msgSend(NS.Integer, self, "allocatedSize") +Resource_allocatedSize :: #force_inline proc(self: ^Resource) -> NS.UInteger { + return msgSend(NS.UInteger, self, "allocatedSize") } @(objc_type=Resource, objc_name="cpuCacheMode") Resource_cpuCacheMode :: #force_inline proc(self: ^Resource) -> CPUCacheMode { @@ -7729,8 +7802,8 @@ Resource_heap :: #force_inline proc(self: ^Resource) -> ^Resource { return msgSend(^Resource, self, "heap") } @(objc_type=Resource, objc_name="heapOffset") -Resource_heapOffset :: #force_inline proc(self: ^Resource) -> NS.Integer { - return msgSend(NS.Integer, self, "heapOffset") +Resource_heapOffset :: #force_inline proc(self: ^Resource) -> NS.UInteger { + return msgSend(NS.UInteger, self, "heapOffset") } @(objc_type=Resource, objc_name="isAliasable") Resource_isAliasable :: #force_inline proc(self: ^Resource) -> BOOL { @@ -7778,23 +7851,23 @@ Methods: ResourceStateCommandEncoder :: struct { using _: NS.Object } @(objc_type=ResourceStateCommandEncoder, objc_name="updateFence") -ResourceStateCommandEncoder_updateFence :: #force_inline proc(self: ^ResourceStateCommandEncoder, fence: ^NS.Object) { +ResourceStateCommandEncoder_updateFence :: #force_inline proc(self: ^ResourceStateCommandEncoder, fence: ^Fence) { msgSend(nil, self, "updateFence:", fence) } @(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMapping_mode_indirectBuffer_indirectBufferOffset_") -ResourceStateCommandEncoder_updateTextureMapping_mode_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^ResourceStateCommandEncoder, texture: ^NS.Object, mode: SparseTextureMappingMode, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) { +ResourceStateCommandEncoder_updateTextureMapping_mode_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^ResourceStateCommandEncoder, texture: ^Texture, mode: SparseTextureMappingMode, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "updateTextureMapping:mode:indirectBuffer:indirectBufferOffset:", texture, mode, indirectBuffer, indirectBufferOffset) } @(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMapping_mode_region_mipLevel_slice_") -ResourceStateCommandEncoder_updateTextureMapping_mode_region_mipLevel_slice_ :: #force_inline proc(self: ^ResourceStateCommandEncoder, texture: ^NS.Object, mode: SparseTextureMappingMode, region: Region, mipLevel: NS.Integer, slice: NS.Integer) { +ResourceStateCommandEncoder_updateTextureMapping_mode_region_mipLevel_slice_ :: #force_inline proc(self: ^ResourceStateCommandEncoder, texture: ^Texture, mode: SparseTextureMappingMode, region: Region, mipLevel: NS.UInteger, slice: NS.UInteger) { msgSend(nil, self, "updateTextureMapping:mode:region:mipLevel:slice:", texture, mode, region, mipLevel, slice) } @(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMappings") -ResourceStateCommandEncoder_updateTextureMappings :: #force_inline proc(self: ^ResourceStateCommandEncoder, texture: ^NS.Object, mode: SparseTextureMappingMode, regions: ^Region, mipLevels: NS.Integer, slices: NS.Integer, numRegions: ^NS.Object) { +ResourceStateCommandEncoder_updateTextureMappings :: #force_inline proc(self: ^ResourceStateCommandEncoder, texture: ^Texture, mode: SparseTextureMappingMode, regions: ^Region, mipLevels: NS.UInteger, slices: NS.UInteger, numRegions: NS.UInteger) { msgSend(nil, self, "updateTextureMappings:mode:regions:mipLevels:slices:numRegions:", texture, mode, regions, mipLevels, slices, numRegions) } @(objc_type=ResourceStateCommandEncoder, objc_name="waitForFence") -ResourceStateCommandEncoder_waitForFence :: #force_inline proc(self: ^ResourceStateCommandEncoder, fence: ^NS.Object) { +ResourceStateCommandEncoder_waitForFence :: #force_inline proc(self: ^ResourceStateCommandEncoder, fence: ^Fence) { msgSend(nil, self, "waitForFence:", fence) } @@ -7896,55 +7969,55 @@ Methods: width */ @(objc_class="MTLTexture") -Texture :: struct { using _: NS.Object } +Texture :: struct { using _: Resource } @(objc_type=Texture, objc_name="allowGPUOptimizedContents") Texture_allowGPUOptimizedContents :: #force_inline proc(self: ^Texture) -> BOOL { return msgSend(BOOL, self, "allowGPUOptimizedContents") } @(objc_type=Texture, objc_name="arrayLength") -Texture_arrayLength :: #force_inline proc(self: ^Texture) -> NS.Integer { - return msgSend(NS.Integer, self, "arrayLength") +Texture_arrayLength :: #force_inline proc(self: ^Texture) -> NS.UInteger { + return msgSend(NS.UInteger, self, "arrayLength") } @(objc_type=Texture, objc_name="buffer") Texture_buffer :: #force_inline proc(self: ^Texture) -> ^Texture { return msgSend(^Texture, self, "buffer") } @(objc_type=Texture, objc_name="bufferBytesPerRow") -Texture_bufferBytesPerRow :: #force_inline proc(self: ^Texture) -> NS.Integer { - return msgSend(NS.Integer, self, "bufferBytesPerRow") +Texture_bufferBytesPerRow :: #force_inline proc(self: ^Texture) -> NS.UInteger { + return msgSend(NS.UInteger, self, "bufferBytesPerRow") } @(objc_type=Texture, objc_name="bufferOffset") -Texture_bufferOffset :: #force_inline proc(self: ^Texture) -> NS.Integer { - return msgSend(NS.Integer, self, "bufferOffset") +Texture_bufferOffset :: #force_inline proc(self: ^Texture) -> NS.UInteger { + return msgSend(NS.UInteger, self, "bufferOffset") } @(objc_type=Texture, objc_name="depth") -Texture_depth :: #force_inline proc(self: ^Texture) -> NS.Integer { - return msgSend(NS.Integer, self, "depth") +Texture_depth :: #force_inline proc(self: ^Texture) -> NS.UInteger { + return msgSend(NS.UInteger, self, "depth") } @(objc_type=Texture, objc_name="firstMipmapInTail") -Texture_firstMipmapInTail :: #force_inline proc(self: ^Texture) -> NS.Integer { - return msgSend(NS.Integer, self, "firstMipmapInTail") +Texture_firstMipmapInTail :: #force_inline proc(self: ^Texture) -> NS.UInteger { + return msgSend(NS.UInteger, self, "firstMipmapInTail") } @(objc_type=Texture, objc_name="getBytes_bytesPerRow_bytesPerImage_fromRegion_mipmapLevel_slice_") -Texture_getBytes_bytesPerRow_bytesPerImage_fromRegion_mipmapLevel_slice_ :: #force_inline proc(self: ^Texture, pixelBytes: rawptr, bytesPerRow: ^NS.Object, bytesPerImage: ^NS.Object, region: Region, level: ^NS.Object, slice: ^NS.Object) { +Texture_getBytes_bytesPerRow_bytesPerImage_fromRegion_mipmapLevel_slice_ :: #force_inline proc(self: ^Texture, pixelBytes: rawptr, bytesPerRow: NS.UInteger, bytesPerImage: NS.UInteger, region: Region, level: NS.UInteger, slice: NS.UInteger) { msgSend(nil, self, "getBytes:bytesPerRow:bytesPerImage:fromRegion:mipmapLevel:slice:", pixelBytes, bytesPerRow, bytesPerImage, region, level, slice) } @(objc_type=Texture, objc_name="getBytes_bytesPerRow_fromRegion_mipmapLevel_") -Texture_getBytes_bytesPerRow_fromRegion_mipmapLevel_ :: #force_inline proc(self: ^Texture, pixelBytes: rawptr, bytesPerRow: ^NS.Object, region: Region, level: ^NS.Object) { +Texture_getBytes_bytesPerRow_fromRegion_mipmapLevel_ :: #force_inline proc(self: ^Texture, pixelBytes: rawptr, bytesPerRow: NS.UInteger, region: Region, level: NS.UInteger) { msgSend(nil, self, "getBytes:bytesPerRow:fromRegion:mipmapLevel:", pixelBytes, bytesPerRow, region, level) } @(objc_type=Texture, objc_name="height") -Texture_height :: #force_inline proc(self: ^Texture) -> NS.Integer { - return msgSend(NS.Integer, self, "height") +Texture_height :: #force_inline proc(self: ^Texture) -> NS.UInteger { + return msgSend(NS.UInteger, self, "height") } @(objc_type=Texture, objc_name="iosurface") Texture_iosurface :: #force_inline proc(self: ^Texture) -> IOSurfaceRef { return msgSend(IOSurfaceRef, self, "iosurface") } @(objc_type=Texture, objc_name="iosurfacePlane") -Texture_iosurfacePlane :: #force_inline proc(self: ^Texture) -> NS.Integer { - return msgSend(NS.Integer, self, "iosurfacePlane") +Texture_iosurfacePlane :: #force_inline proc(self: ^Texture) -> NS.UInteger { + return msgSend(NS.UInteger, self, "iosurfacePlane") } @(objc_type=Texture, objc_name="isFramebufferOnly") Texture_isFramebufferOnly :: #force_inline proc(self: ^Texture) -> BOOL { @@ -7959,11 +8032,11 @@ Texture_isSparse :: #force_inline proc(self: ^Texture) -> BOOL { return msgSend(BOOL, self, "isSparse") } @(objc_type=Texture, objc_name="mipmapLevelCount") -Texture_mipmapLevelCount :: #force_inline proc(self: ^Texture) -> NS.Integer { - return msgSend(NS.Integer, self, "mipmapLevelCount") +Texture_mipmapLevelCount :: #force_inline proc(self: ^Texture) -> NS.UInteger { + return msgSend(NS.UInteger, self, "mipmapLevelCount") } @(objc_type=Texture, objc_name="newRemoteTextureViewForDevice") -Texture_newRemoteTextureViewForDevice :: #force_inline proc(self: ^Texture, device: ^NS.Object) -> ^Texture { +Texture_newRemoteTextureViewForDevice :: #force_inline proc(self: ^Texture, device: ^Device) -> ^Texture { return msgSend(^Texture, self, "newRemoteTextureViewForDevice:", device) } @(objc_type=Texture, objc_name="newSharedTextureHandle") @@ -7983,12 +8056,12 @@ Texture_newTextureViewWithPixelFormat_textureType_levels_slices_swizzle_ :: #for return msgSend(^Texture, self, "newTextureViewWithPixelFormat:textureType:levels:slices:swizzle:", pixelFormat, textureType, levelRange, sliceRange, swizzle) } @(objc_type=Texture, objc_name="parentRelativeLevel") -Texture_parentRelativeLevel :: #force_inline proc(self: ^Texture) -> NS.Integer { - return msgSend(NS.Integer, self, "parentRelativeLevel") +Texture_parentRelativeLevel :: #force_inline proc(self: ^Texture) -> NS.UInteger { + return msgSend(NS.UInteger, self, "parentRelativeLevel") } @(objc_type=Texture, objc_name="parentRelativeSlice") -Texture_parentRelativeSlice :: #force_inline proc(self: ^Texture) -> NS.Integer { - return msgSend(NS.Integer, self, "parentRelativeSlice") +Texture_parentRelativeSlice :: #force_inline proc(self: ^Texture) -> NS.UInteger { + return msgSend(NS.UInteger, self, "parentRelativeSlice") } @(objc_type=Texture, objc_name="parentTexture") Texture_parentTexture :: #force_inline proc(self: ^Texture) -> ^Texture { @@ -8003,11 +8076,11 @@ Texture_remoteStorageTexture :: #force_inline proc(self: ^Texture) -> ^Texture { return msgSend(^Texture, self, "remoteStorageTexture") } @(objc_type=Texture, objc_name="replaceRegion_mipmapLevel_slice_withBytes_bytesPerRow_bytesPerImage_") -Texture_replaceRegion_mipmapLevel_slice_withBytes_bytesPerRow_bytesPerImage_ :: #force_inline proc(self: ^Texture, region: Region, level: ^NS.Object, slice: ^NS.Object, pixelBytes: rawptr, bytesPerRow: ^NS.Object, bytesPerImage: ^NS.Object) { +Texture_replaceRegion_mipmapLevel_slice_withBytes_bytesPerRow_bytesPerImage_ :: #force_inline proc(self: ^Texture, region: Region, level: NS.UInteger, slice: NS.UInteger, pixelBytes: rawptr, bytesPerRow: NS.UInteger, bytesPerImage: NS.UInteger) { msgSend(nil, self, "replaceRegion:mipmapLevel:slice:withBytes:bytesPerRow:bytesPerImage:", region, level, slice, pixelBytes, bytesPerRow, bytesPerImage) } @(objc_type=Texture, objc_name="replaceRegion_mipmapLevel_withBytes_bytesPerRow_") -Texture_replaceRegion_mipmapLevel_withBytes_bytesPerRow_ :: #force_inline proc(self: ^Texture, region: Region, level: ^NS.Object, pixelBytes: rawptr, bytesPerRow: ^NS.Object) { +Texture_replaceRegion_mipmapLevel_withBytes_bytesPerRow_ :: #force_inline proc(self: ^Texture, region: Region, level: NS.UInteger, pixelBytes: rawptr, bytesPerRow: NS.UInteger) { msgSend(nil, self, "replaceRegion:mipmapLevel:withBytes:bytesPerRow:", region, level, pixelBytes, bytesPerRow) } @(objc_type=Texture, objc_name="rootResource") @@ -8015,16 +8088,16 @@ Texture_rootResource :: #force_inline proc(self: ^Texture) -> ^Texture { return msgSend(^Texture, self, "rootResource") } @(objc_type=Texture, objc_name="sampleCount") -Texture_sampleCount :: #force_inline proc(self: ^Texture) -> NS.Integer { - return msgSend(NS.Integer, self, "sampleCount") +Texture_sampleCount :: #force_inline proc(self: ^Texture) -> NS.UInteger { + return msgSend(NS.UInteger, self, "sampleCount") } @(objc_type=Texture, objc_name="swizzle") Texture_swizzle :: #force_inline proc(self: ^Texture) -> TextureSwizzleChannels { return msgSend(TextureSwizzleChannels, self, "swizzle") } @(objc_type=Texture, objc_name="tailSizeInBytes") -Texture_tailSizeInBytes :: #force_inline proc(self: ^Texture) -> NS.Integer { - return msgSend(NS.Integer, self, "tailSizeInBytes") +Texture_tailSizeInBytes :: #force_inline proc(self: ^Texture) -> NS.UInteger { + return msgSend(NS.UInteger, self, "tailSizeInBytes") } @(objc_type=Texture, objc_name="textureType") Texture_textureType :: #force_inline proc(self: ^Texture) -> TextureType { @@ -8035,8 +8108,8 @@ Texture_usage :: #force_inline proc(self: ^Texture) -> TextureUsage { return msgSend(TextureUsage, self, "usage") } @(objc_type=Texture, objc_name="width") -Texture_width :: #force_inline proc(self: ^Texture) -> NS.Integer { - return msgSend(NS.Integer, self, "width") +Texture_width :: #force_inline proc(self: ^Texture) -> NS.UInteger { + return msgSend(NS.UInteger, self, "width") } //////////////////////////////////////////////////////////////////////////////// @@ -8050,13 +8123,13 @@ Methods: setFunctions */ @(objc_class="MTLVisibleFunctionTable") -VisibleFunctionTable :: struct { using _: NS.Object } +VisibleFunctionTable :: struct { using _: Resource } @(objc_type=VisibleFunctionTable, objc_name="setFunction") -VisibleFunctionTable_setFunction :: #force_inline proc(self: ^VisibleFunctionTable, function: ^NS.Object, index: ^NS.Object) { +VisibleFunctionTable_setFunction :: #force_inline proc(self: ^VisibleFunctionTable, function: ^FunctionHandle, index: NS.UInteger) { msgSend(nil, self, "setFunction:atIndex:", function, index) } @(objc_type=VisibleFunctionTable, objc_name="setFunctions") -VisibleFunctionTable_setFunctions :: #force_inline proc(self: ^VisibleFunctionTable, functions: ^^NS.Object, range: NS.Range) { +VisibleFunctionTable_setFunctions :: #force_inline proc(self: ^VisibleFunctionTable, functions: [^]^FunctionHandle, range: NS.Range) { msgSend(nil, self, "setFunctions:withRange:", functions, range) } diff --git a/core/sys/darwin/Metal/MetalProcedures.odin b/core/sys/darwin/Metal/MetalProcedures.odin index 120396b5d..6db5fe316 100644 --- a/core/sys/darwin/Metal/MetalProcedures.odin +++ b/core/sys/darwin/Metal/MetalProcedures.odin @@ -8,7 +8,7 @@ foreign import "system:Metal.framework" @(default_calling_convention="c", link_prefix="MTL") foreign Metal { CopyAllDevices :: proc() -> ^NS.Array --- - CopyAllDevicesWithObserver :: proc(observer: ^^NS.Object, handler: DeviceNotificationHandler) -> ^NS.Array --- - CreateSystemDefaultDevice :: proc() -> ^NS.Object --- - RemoveDeviceObserver :: proc(observer: ^NS.Object) --- + CopyAllDevicesWithObserver :: proc(observer: ^id, handler: DeviceNotificationHandler) -> ^NS.Array --- + CreateSystemDefaultDevice :: proc() -> ^Device --- + RemoveDeviceObserver :: proc(observer: id) --- } \ No newline at end of file diff --git a/core/sys/darwin/Metal/MetalTypes.odin b/core/sys/darwin/Metal/MetalTypes.odin index c8c02e5f2..24a951853 100644 --- a/core/sys/darwin/Metal/MetalTypes.odin +++ b/core/sys/darwin/Metal/MetalTypes.odin @@ -4,11 +4,15 @@ import NS "core:sys/darwin/Foundation" import "core:intrinsics" BOOL :: NS.BOOL +id :: ^NS.Object CFTimeInterval :: NS.TimeInterval IOSurfaceRef :: distinct rawptr +dispatch_queue_t :: id +dispatch_data_t :: id + @(private) msgSend :: intrinsics.objc_send diff --git a/examples/objc/objc_main.odin b/examples/objc/objc_main.odin new file mode 100644 index 000000000..0f8d1f5bf --- /dev/null +++ b/examples/objc/objc_main.odin @@ -0,0 +1,8 @@ +package objc_test + +import NS "core:sys/darwin/Foundation" +import MTL "core:sys/darwin/Metal" + +main :: proc() { + +} \ No newline at end of file From b647b45ba50c4cb7de0fab970da73212f9a74176 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Sat, 12 Feb 2022 21:25:20 +0000 Subject: [PATCH 18/64] Remove temp file --- examples/objc/objc_main.odin | 8 -------- 1 file changed, 8 deletions(-) delete mode 100644 examples/objc/objc_main.odin diff --git a/examples/objc/objc_main.odin b/examples/objc/objc_main.odin deleted file mode 100644 index 0f8d1f5bf..000000000 --- a/examples/objc/objc_main.odin +++ /dev/null @@ -1,8 +0,0 @@ -package objc_test - -import NS "core:sys/darwin/Foundation" -import MTL "core:sys/darwin/Metal" - -main :: proc() { - -} \ No newline at end of file From 39a0f8c96a4cd35d0593ed9230e2434859212f58 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Sat, 12 Feb 2022 21:28:56 +0000 Subject: [PATCH 19/64] Use distinct array types --- core/sys/darwin/Metal/MetalTypes.odin | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/core/sys/darwin/Metal/MetalTypes.odin b/core/sys/darwin/Metal/MetalTypes.odin index 24a951853..e1269f926 100644 --- a/core/sys/darwin/Metal/MetalTypes.odin +++ b/core/sys/darwin/Metal/MetalTypes.odin @@ -131,10 +131,7 @@ Region :: struct { size: Size, } -SamplePosition :: struct { - x: f32, - y: f32, -} +SamplePosition :: distinct [2]f32 ScissorRect :: struct { x: NS.Integer, From e2aa8f426da252f946af743a624cd097b7f09937 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Sat, 12 Feb 2022 21:45:34 +0000 Subject: [PATCH 20/64] Improve type hierarchy and method names --- core/sys/darwin/Metal/MetalClasses.odin | 162 ++++++++++++------------ 1 file changed, 81 insertions(+), 81 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 5695cbb6f..159cc723b 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -22,7 +22,7 @@ Methods: setBoundingBoxStride */ @(objc_class="MTLAccelerationStructureBoundingBoxGeometryDescriptor") -AccelerationStructureBoundingBoxGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureBoundingBoxGeometryDescriptor) } +AccelerationStructureBoundingBoxGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureBoundingBoxGeometryDescriptor), using _: AccelerationStructureDescriptor } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_class_name="alloc") AccelerationStructureBoundingBoxGeometryDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureBoundingBoxGeometryDescriptor { @@ -227,7 +227,7 @@ Methods: vertexStride */ @(objc_class="MTLAccelerationStructureTriangleGeometryDescriptor") -AccelerationStructureTriangleGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureTriangleGeometryDescriptor) } +AccelerationStructureTriangleGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureTriangleGeometryDescriptor), using _: AccelerationStructureDescriptor } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_class_name="alloc") AccelerationStructureTriangleGeometryDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureTriangleGeometryDescriptor { @@ -506,7 +506,7 @@ Methods: stride */ @(objc_class="MTLArrayType") -ArrayType :: struct { using _: NS.Object } +ArrayType :: struct { using _: Type } @(objc_type=ArrayType, objc_class_name="alloc") ArrayType_alloc :: #force_inline proc() -> ^ArrayType { @@ -1974,7 +1974,7 @@ Methods: setInstancedAccelerationStructures */ @(objc_class="MTLInstanceAccelerationStructureDescriptor") -InstanceAccelerationStructureDescriptor :: struct { using _: NS.Copying(InstanceAccelerationStructureDescriptor) } +InstanceAccelerationStructureDescriptor :: struct { using _: NS.Copying(InstanceAccelerationStructureDescriptor), using _: AccelerationStructureDescriptor } @(objc_type=InstanceAccelerationStructureDescriptor, objc_class_name="alloc") InstanceAccelerationStructureDescriptor_alloc :: #force_inline proc() -> ^InstanceAccelerationStructureDescriptor { @@ -2205,7 +2205,7 @@ Methods: elementType */ @(objc_class="MTLPointerType") -PointerType :: struct { using _: NS.Object } +PointerType :: struct { using _: Type } @(objc_type=PointerType, objc_class_name="alloc") PointerType_alloc :: #force_inline proc() -> ^PointerType { @@ -2258,7 +2258,7 @@ Methods: setGeometryDescriptors */ @(objc_class="MTLPrimitiveAccelerationStructureDescriptor") -PrimitiveAccelerationStructureDescriptor :: struct { using _: NS.Copying(PrimitiveAccelerationStructureDescriptor) } +PrimitiveAccelerationStructureDescriptor :: struct { using _: NS.Copying(PrimitiveAccelerationStructureDescriptor), using _: AccelerationStructureDescriptor } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_class_name="alloc") PrimitiveAccelerationStructureDescriptor_alloc :: #force_inline proc() -> ^PrimitiveAccelerationStructureDescriptor { @@ -2624,7 +2624,7 @@ Methods: setClearColor */ @(objc_class="MTLRenderPassColorAttachmentDescriptor") -RenderPassColorAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassColorAttachmentDescriptor) } +RenderPassColorAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassColorAttachmentDescriptor), using _: RenderPassAttachmentDescriptor } @(objc_type=RenderPassColorAttachmentDescriptor, objc_class_name="alloc") RenderPassColorAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPassColorAttachmentDescriptor { @@ -2690,7 +2690,7 @@ Methods: setDepthResolveFilter */ @(objc_class="MTLRenderPassDepthAttachmentDescriptor") -RenderPassDepthAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassDepthAttachmentDescriptor) } +RenderPassDepthAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassDepthAttachmentDescriptor), using _: RenderPassAttachmentDescriptor } @(objc_type=RenderPassDepthAttachmentDescriptor, objc_class_name="alloc") RenderPassDepthAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPassDepthAttachmentDescriptor { @@ -2757,7 +2757,7 @@ Methods: visibilityResultBuffer */ @(objc_class="MTLRenderPassDescriptor") -RenderPassDescriptor :: struct { using _: NS.Copying(RenderPassDescriptor) } +RenderPassDescriptor :: struct { using _: NS.Copying(RenderPassDescriptor), using _: AccelerationStructureDescriptor } @(objc_type=RenderPassDescriptor, objc_class_name="alloc") RenderPassDescriptor_alloc :: #force_inline proc() -> ^RenderPassDescriptor { @@ -3059,7 +3059,7 @@ Methods: writeMask */ @(objc_class="MTLRenderPipelineColorAttachmentDescriptor") -RenderPipelineColorAttachmentDescriptor :: struct { using _: NS.Copying(RenderPipelineColorAttachmentDescriptor) } +RenderPipelineColorAttachmentDescriptor :: struct { using _: NS.Copying(RenderPipelineColorAttachmentDescriptor), using _: RenderPassAttachmentDescriptor } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_class_name="alloc") RenderPipelineColorAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPipelineColorAttachmentDescriptor { @@ -4071,7 +4071,7 @@ Methods: members */ @(objc_class="MTLStructType") -StructType :: struct { using _: NS.Object } +StructType :: struct { using _: Type } @(objc_type=StructType, objc_class_name="alloc") StructType_alloc :: #force_inline proc() -> ^StructType { @@ -4292,7 +4292,7 @@ Methods: textureType */ @(objc_class="MTLTextureReferenceType") -TextureReferenceType :: struct { using _: NS.Object } +TextureReferenceType :: struct { using _: Type } @(objc_type=TextureReferenceType, objc_class_name="alloc") TextureReferenceType_alloc :: #force_inline proc() -> ^TextureReferenceType { @@ -4844,7 +4844,7 @@ Methods: writeCompactedAccelerationStructureSize */ @(objc_class="MTLAccelerationStructureCommandEncoder") -AccelerationStructureCommandEncoder :: struct { using _: NS.Object } +AccelerationStructureCommandEncoder :: struct { using _: CommandEncoder } @(objc_type=AccelerationStructureCommandEncoder, objc_name="buildAccelerationStructure") AccelerationStructureCommandEncoder_buildAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, accelerationStructure: ^AccelerationStructure, descriptor: ^AccelerationStructureDescriptor, scratchBuffer: ^Buffer, scratchBufferOffset: NS.UInteger) { @@ -5122,14 +5122,14 @@ Methods: waitForFence */ @(objc_class="MTLBlitCommandEncoder") -BlitCommandEncoder :: struct { using _: NS.Object } +BlitCommandEncoder :: struct { using _: CommandEncoder } @(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_") -BlitCommandEncoder_copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^Buffer, sourceOffset: NS.UInteger, sourceBytesPerRow: NS.UInteger, sourceBytesPerImage: NS.UInteger, sourceSize: Size, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, destinationOrigin: Origin) { +BlitCommandEncoder_copyFromBufferEx :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^Buffer, sourceOffset: NS.UInteger, sourceBytesPerRow: NS.UInteger, sourceBytesPerImage: NS.UInteger, sourceSize: Size, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, destinationOrigin: Origin) { msgSend(nil, self, "copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:", sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin) } @(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_") -BlitCommandEncoder_copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^Buffer, sourceOffset: NS.UInteger, sourceBytesPerRow: NS.UInteger, sourceBytesPerImage: NS.UInteger, sourceSize: Size, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, destinationOrigin: Origin, options: BlitOption) { +BlitCommandEncoder_copyFromBufferExWithOptions :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^Buffer, sourceOffset: NS.UInteger, sourceBytesPerRow: NS.UInteger, sourceBytesPerImage: NS.UInteger, sourceSize: Size, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, destinationOrigin: Origin, options: BlitOption) { msgSend(nil, self, "copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:options:", sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin, options) } @(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_") @@ -5676,7 +5676,7 @@ Methods: waitForFence */ @(objc_class="MTLComputeCommandEncoder") -ComputeCommandEncoder :: struct { using _: NS.Object } +ComputeCommandEncoder :: struct { using _: CommandEncoder } @(objc_type=ComputeCommandEncoder, objc_name="dispatchThreadgroups") ComputeCommandEncoder_dispatchThreadgroups :: #force_inline proc(self: ^ComputeCommandEncoder, threadgroupsPerGrid: Size, threadsPerThreadgroup: Size) { @@ -6231,30 +6231,30 @@ Device_newCommandQueue :: #force_inline proc(self: ^Device) -> ^Device { Device_newCommandQueueWithMaxCommandBufferCount :: #force_inline proc(self: ^Device, maxCommandBufferCount: NS.UInteger) -> ^Device { return msgSend(^Device, self, "newCommandQueueWithMaxCommandBufferCount:", maxCommandBufferCount) } -@(objc_type=Device, objc_name="newComputePipelineStateWithDescriptor_options_completionHandler_") -Device_newComputePipelineStateWithDescriptor_options_completionHandler_ :: #force_inline proc(self: ^Device, descriptor: ^ComputePipelineDescriptor, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) { +@(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) } -@(objc_type=Device, objc_name="newComputePipelineStateWithDescriptor_options_reflection_error_") -Device_newComputePipelineStateWithDescriptor_options_reflection_error_ :: #force_inline proc(self: ^Device, descriptor: ^ComputePipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection) -> (device: ^Device, error: ^NS.Error) { +@(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) return } -@(objc_type=Device, objc_name="newComputePipelineStateWithFunction_completionHandler_") -Device_newComputePipelineStateWithFunction_completionHandler_ :: #force_inline proc(self: ^Device, computeFunction: ^Function, completionHandler: NewComputePipelineStateCompletionHandler) { +@(objc_type=Device, objc_name="newComputePipelineStateWithFunctionWithCompletionHandler") +Device_newComputePipelineStateWithFunctionWithCompletionHandler :: #force_inline proc(self: ^Device, computeFunction: ^Function, completionHandler: NewComputePipelineStateCompletionHandler) { msgSend(nil, self, "newComputePipelineStateWithFunction:completionHandler:", computeFunction, completionHandler) } -@(objc_type=Device, objc_name="newComputePipelineStateWithFunction_error_") -Device_newComputePipelineStateWithFunction_error_ :: #force_inline proc(self: ^Device, computeFunction: ^Function) -> (device: ^Device, error: ^NS.Error) { +@(objc_type=Device, objc_name="newComputePipelineStateWithFunction") +Device_newComputePipelineStateWithFunction :: #force_inline proc(self: ^Device, computeFunction: ^Function) -> (device: ^Device, error: ^NS.Error) { device = msgSend(^Device, self, "newComputePipelineStateWithFunction:error:", computeFunction, &error) return } -@(objc_type=Device, objc_name="newComputePipelineStateWithFunction_options_completionHandler_") -Device_newComputePipelineStateWithFunction_options_completionHandler_ :: #force_inline proc(self: ^Device, computeFunction: ^Function, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) { +@(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) } -@(objc_type=Device, objc_name="newComputePipelineStateWithFunction_options_reflection_error_") -Device_newComputePipelineStateWithFunction_options_reflection_error_ :: #force_inline proc(self: ^Device, computeFunction: ^Function, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection) -> (device: ^Device, error: ^NS.Error) { +@(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) return } @@ -6312,12 +6312,12 @@ Device_newLibraryWithFile :: #force_inline proc(self: ^Device, filepath: ^NS.Str device = msgSend(^Device, self, "newLibraryWithFile:error:", filepath, &error) return } -@(objc_type=Device, objc_name="newLibraryWithSource_options_completionHandler_") -Device_newLibraryWithSource_options_completionHandler_ :: #force_inline proc(self: ^Device, source: ^NS.String, options: ^CompileOptions, completionHandler: NewLibraryCompletionHandler) { +@(objc_type=Device, objc_name="newLibraryWithSourceWithCompletionHandler") +Device_newLibraryWithSourceWithCompletionHandler :: #force_inline proc(self: ^Device, source: ^NS.String, options: ^CompileOptions, completionHandler: NewLibraryCompletionHandler) { msgSend(nil, self, "newLibraryWithSource:options:completionHandler:", source, options, completionHandler) } -@(objc_type=Device, objc_name="newLibraryWithSource_options_error_") -Device_newLibraryWithSource_options_error_ :: #force_inline proc(self: ^Device, source: ^NS.String, options: ^CompileOptions) -> (device: ^Device, error: ^NS.Error) { +@(objc_type=Device, objc_name="newLibraryWithSource") +Device_newLibraryWithSource :: #force_inline proc(self: ^Device, source: ^NS.String, options: ^CompileOptions) -> (device: ^Device, error: ^NS.Error) { device = msgSend(^Device, self, "newLibraryWithSource:options:error:", source, options, &error) return } @@ -6330,30 +6330,30 @@ Device_newLibraryWithURL :: #force_inline proc(self: ^Device, url: ^NS.URL) -> ( Device_newRasterizationRateMapWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^RasterizationRateMapDescriptor) -> ^Device { return msgSend(^Device, self, "newRasterizationRateMapWithDescriptor:", descriptor) } -@(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor_completionHandler_") -Device_newRenderPipelineStateWithDescriptor_completionHandler_ :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, completionHandler: NewRenderPipelineStateCompletionHandler) { +@(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptorWithCompletionHandler") +Device_newRenderPipelineStateWithDescriptorWithCompletionHandler :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, completionHandler: NewRenderPipelineStateCompletionHandler) { msgSend(nil, self, "newRenderPipelineStateWithDescriptor:completionHandler:", descriptor, completionHandler) } -@(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor_error_") -Device_newRenderPipelineStateWithDescriptor_error_ :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor) -> (device: ^Device, error: ^NS.Error) { +@(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor") +Device_newRenderPipelineStateWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor) -> (device: ^Device, error: ^NS.Error) { device = msgSend(^Device, self, "newRenderPipelineStateWithDescriptor:error:", descriptor, &error) return } -@(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor_options_completionHandler_") -Device_newRenderPipelineStateWithDescriptor_options_completionHandler_ :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, completionHandler: NewRenderPipelineStateWithReflectionCompletionHandler) { +@(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptorWithOptionsAndCompletionHandler") +Device_newRenderPipelineStateWithDescriptorWithOptionsAndCompletionHandler :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, completionHandler: NewRenderPipelineStateWithReflectionCompletionHandler) { msgSend(nil, self, "newRenderPipelineStateWithDescriptor:options:completionHandler:", descriptor, options, completionHandler) } -@(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor_options_reflection_error_") -Device_newRenderPipelineStateWithDescriptor_options_reflection_error_ :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection) -> (device: ^Device, error: ^NS.Error) { +@(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptorWithReflection") +Device_newRenderPipelineStateWithDescriptorWithReflection :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection) -> (device: ^Device, error: ^NS.Error) { device = msgSend(^Device, self, "newRenderPipelineStateWithDescriptor:options:reflection:error:", descriptor, options, reflection, &error) return } -@(objc_type=Device, objc_name="newRenderPipelineStateWithTileDescriptor_options_completionHandler_") -Device_newRenderPipelineStateWithTileDescriptor_options_completionHandler_ :: #force_inline proc(self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, completionHandler: NewRenderPipelineStateWithReflectionCompletionHandler) { +@(objc_type=Device, objc_name="newRenderPipelineStateWithTileDescriptorWithCompletionHandler") +Device_newRenderPipelineStateWithTileDescriptorWithCompletionHandler :: #force_inline proc(self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, completionHandler: NewRenderPipelineStateWithReflectionCompletionHandler) { msgSend(nil, self, "newRenderPipelineStateWithTileDescriptor:options:completionHandler:", descriptor, options, completionHandler) } -@(objc_type=Device, objc_name="newRenderPipelineStateWithTileDescriptor_options_reflection_error_") -Device_newRenderPipelineStateWithTileDescriptor_options_reflection_error_ :: #force_inline proc(self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection) -> (device: ^Device, error: ^NS.Error) { +@(objc_type=Device, objc_name="newRenderPipelineStateWithTileDescriptorWithReflection") +Device_newRenderPipelineStateWithTileDescriptorWithReflection :: #force_inline proc(self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection) -> (device: ^Device, error: ^NS.Error) { device = msgSend(^Device, self, "newRenderPipelineStateWithTileDescriptor:options:reflection:error:", descriptor, options, reflection, &error) return } @@ -6381,8 +6381,8 @@ Device_newSharedTextureWithHandle :: #force_inline proc(self: ^Device, sharedHan Device_newTextureWithDescriptor :: #force_inline proc(self: ^Device, desc: ^TextureDescriptor) -> ^Device { return msgSend(^Device, self, "newTextureWithDescriptor:", desc) } -@(objc_type=Device, objc_name="newTextureWithDescriptor_iosurface_plane_") -Device_newTextureWithDescriptor_iosurface_plane_ :: #force_inline proc(self: ^Device, descriptor: ^TextureDescriptor, iosurface: IOSurfaceRef, plane: NS.UInteger) -> ^Device { +@(objc_type=Device, objc_name="newTextureWithDescriptorWithIOSurface") +Device_newTextureWithDescriptorWithIOSurface :: #force_inline proc(self: ^Device, descriptor: ^TextureDescriptor, iosurface: IOSurfaceRef, plane: NS.UInteger) -> ^Device { return msgSend(^Device, self, "newTextureWithDescriptor:iosurface:plane:", descriptor, iosurface, plane) } @(objc_type=Device, objc_name="peerCount") @@ -6664,8 +6664,8 @@ Function_name :: #force_inline proc(self: ^Function) -> ^NS.String { Function_newArgumentEncoderWithBufferIndex :: #force_inline proc(self: ^Function, bufferIndex: NS.UInteger) -> ^Function { return msgSend(^Function, self, "newArgumentEncoderWithBufferIndex:", bufferIndex) } -@(objc_type=Function, objc_name="newArgumentEncoderWithBufferIndex_reflection_") -Function_newArgumentEncoderWithBufferIndex_reflection_ :: #force_inline proc(self: ^Function, bufferIndex: NS.UInteger, reflection: ^AutoreleasedArgument) -> ^Function { +@(objc_type=Function, objc_name="newArgumentEncoderWithBufferIndexWithReflection") +Function_newArgumentEncoderWithBufferIndexWithReflection :: #force_inline proc(self: ^Function, bufferIndex: NS.UInteger, reflection: ^AutoreleasedArgument) -> ^Function { return msgSend(^Function, self, "newArgumentEncoderWithBufferIndex:reflection:", bufferIndex, reflection) } @(objc_type=Function, objc_name="options") @@ -6840,16 +6840,16 @@ Heap_maxAvailableSizeWithAlignment :: #force_inline proc(self: ^Heap, alignment: Heap_newBufferWithLength :: #force_inline proc(self: ^Heap, length: NS.UInteger, options: ResourceOptions) -> ^Heap { return msgSend(^Heap, self, "newBufferWithLength:options:", length, options) } -@(objc_type=Heap, objc_name="newBufferWithLength_options_offset_") -Heap_newBufferWithLength_options_offset_ :: #force_inline proc(self: ^Heap, length: NS.UInteger, options: ResourceOptions, offset: NS.UInteger) -> ^Heap { +@(objc_type=Heap, objc_name="newBufferWithLengthWithOptions") +Heap_newBufferWithLengthWithOptions :: #force_inline proc(self: ^Heap, length: NS.UInteger, options: ResourceOptions, offset: NS.UInteger) -> ^Heap { return msgSend(^Heap, self, "newBufferWithLength:options:offset:", length, options, offset) } @(objc_type=Heap, objc_name="newTextureWithDescriptor") Heap_newTextureWithDescriptor :: #force_inline proc(self: ^Heap, desc: ^TextureDescriptor) -> ^Heap { return msgSend(^Heap, self, "newTextureWithDescriptor:", desc) } -@(objc_type=Heap, objc_name="newTextureWithDescriptor_offset_") -Heap_newTextureWithDescriptor_offset_ :: #force_inline proc(self: ^Heap, descriptor: ^TextureDescriptor, offset: NS.UInteger) -> ^Heap { +@(objc_type=Heap, objc_name="newTextureWithDescriptorWithOffset") +Heap_newTextureWithDescriptorWithOffset :: #force_inline proc(self: ^Heap, descriptor: ^TextureDescriptor, offset: NS.UInteger) -> ^Heap { return msgSend(^Heap, self, "newTextureWithDescriptor:offset:", descriptor, offset) } @(objc_type=Heap, objc_name="resourceOptions") @@ -7119,12 +7119,12 @@ Library_installName :: #force_inline proc(self: ^Library) -> ^NS.String { Library_label :: #force_inline proc(self: ^Library) -> ^NS.String { return msgSend(^NS.String, self, "label") } -@(objc_type=Library, objc_name="newFunctionWithDescriptor_completionHandler_") -Library_newFunctionWithDescriptor_completionHandler_ :: #force_inline proc(self: ^Library, descriptor: ^FunctionDescriptor, completionHandler: rawptr) { +@(objc_type=Library, objc_name="newFunctionWithDescriptorWithCompletionHandler") +Library_newFunctionWithDescriptorWithCompletionHandler :: #force_inline proc(self: ^Library, descriptor: ^FunctionDescriptor, completionHandler: rawptr) { msgSend(nil, self, "newFunctionWithDescriptor:completionHandler:", descriptor, completionHandler) } -@(objc_type=Library, objc_name="newFunctionWithDescriptor_error_") -Library_newFunctionWithDescriptor_error_ :: #force_inline proc(self: ^Library, descriptor: ^FunctionDescriptor) -> (library: ^Library, error: ^NS.Error) { +@(objc_type=Library, objc_name="newFunctionWithDescriptor") +Library_newFunctionWithDescriptor :: #force_inline proc(self: ^Library, descriptor: ^FunctionDescriptor) -> (library: ^Library, error: ^NS.Error) { library = msgSend(^Library, self, "newFunctionWithDescriptor:error:", descriptor, &error) return } @@ -7132,21 +7132,21 @@ Library_newFunctionWithDescriptor_error_ :: #force_inline proc(self: ^Library, d Library_newFunctionWithName :: #force_inline proc(self: ^Library, functionName: ^NS.String) -> ^Library { return msgSend(^Library, self, "newFunctionWithName:", functionName) } -@(objc_type=Library, objc_name="newFunctionWithName_constantValues_completionHandler_") -Library_newFunctionWithName_constantValues_completionHandler_ :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues, completionHandler: rawptr) { +@(objc_type=Library, objc_name="newFunctionWithNameWithConstantValuesAndCompletionHandler") +Library_newFunctionWithNameWithConstantValuesAndCompletionHandler :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues, completionHandler: rawptr) { msgSend(nil, self, "newFunctionWithName:constantValues:completionHandler:", name, constantValues, completionHandler) } -@(objc_type=Library, objc_name="newFunctionWithName_constantValues_error_") -Library_newFunctionWithName_constantValues_error_ :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues) -> (library: ^Library, error: ^NS.Error) { +@(objc_type=Library, objc_name="newFunctionWithNameWithConstantValues") +Library_newFunctionWithNameWithConstantValues :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues) -> (library: ^Library, error: ^NS.Error) { library = msgSend(^Library, self, "newFunctionWithName:constantValues:error:", name, constantValues, &error) return } -@(objc_type=Library, objc_name="newIntersectionFunctionWithDescriptor_completionHandler_") -Library_newIntersectionFunctionWithDescriptor_completionHandler_ :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor, completionHandler: rawptr) { +@(objc_type=Library, objc_name="newIntersectionFunctionWithDescriptorWithCompletionHandler") +Library_newIntersectionFunctionWithDescriptorWithCompletionHandler :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor, completionHandler: rawptr) { msgSend(nil, self, "newIntersectionFunctionWithDescriptor:completionHandler:", descriptor, completionHandler) } -@(objc_type=Library, objc_name="newIntersectionFunctionWithDescriptor_error_") -Library_newIntersectionFunctionWithDescriptor_error_ :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor) -> (library: ^Library, error: ^NS.Error) { +@(objc_type=Library, objc_name="newIntersectionFunctionWithDescriptor") +Library_newIntersectionFunctionWithDescriptor :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor) -> (library: ^Library, error: ^NS.Error) { library = msgSend(^Library, self, "newIntersectionFunctionWithDescriptor:error:", descriptor, &error) return } @@ -7175,7 +7175,7 @@ Methods: setStencilStoreActionOptions */ @(objc_class="MTLParallelRenderCommandEncoder") -ParallelRenderCommandEncoder :: struct { using _: NS.Object } +ParallelRenderCommandEncoder :: struct { using _: CommandEncoder } @(objc_type=ParallelRenderCommandEncoder, objc_name="renderCommandEncoder") ParallelRenderCommandEncoder_renderCommandEncoder :: #force_inline proc(self: ^ParallelRenderCommandEncoder) -> ^ParallelRenderCommandEncoder { @@ -7363,7 +7363,7 @@ Methods: waitForFence */ @(objc_class="MTLRenderCommandEncoder") -RenderCommandEncoder :: struct { using _: NS.Object } +RenderCommandEncoder :: struct { using _: CommandEncoder } @(objc_type=RenderCommandEncoder, objc_name="dispatchThreadsPerTile") RenderCommandEncoder_dispatchThreadsPerTile :: #force_inline proc(self: ^RenderCommandEncoder, threadsPerTile: Size) { @@ -7677,32 +7677,32 @@ RenderCommandEncoder_updateFence :: #force_inline proc(self: ^RenderCommandEncod RenderCommandEncoder_useHeap :: #force_inline proc(self: ^RenderCommandEncoder, heap: ^Heap) { msgSend(nil, self, "useHeap:", heap) } -@(objc_type=RenderCommandEncoder, objc_name="useHeap_stages_") -RenderCommandEncoder_useHeap_stages_ :: #force_inline proc(self: ^RenderCommandEncoder, heap: ^Heap, stages: RenderStages) { +@(objc_type=RenderCommandEncoder, objc_name="useHeapWithStages") +RenderCommandEncoder_useHeapWithStages :: #force_inline proc(self: ^RenderCommandEncoder, heap: ^Heap, stages: RenderStages) { msgSend(nil, self, "useHeap:stages:", heap, stages) } @(objc_type=RenderCommandEncoder, objc_name="useHeaps") RenderCommandEncoder_useHeaps :: #force_inline proc(self: ^RenderCommandEncoder, heaps: [^]^Heap, count: NS.UInteger) { msgSend(nil, self, "useHeaps:count:", heaps, count) } -@(objc_type=RenderCommandEncoder, objc_name="useHeaps_count_stages_") -RenderCommandEncoder_useHeaps_count_stages_ :: #force_inline proc(self: ^RenderCommandEncoder, heaps: [^]^Heap, count: NS.UInteger, stages: RenderStages) { +@(objc_type=RenderCommandEncoder, objc_name="useHeapsWithStages") +RenderCommandEncoder_useHeapsWithStages :: #force_inline proc(self: ^RenderCommandEncoder, heaps: [^]^Heap, count: NS.UInteger, stages: RenderStages) { msgSend(nil, self, "useHeaps:count:stages:", heaps, count, stages) } @(objc_type=RenderCommandEncoder, objc_name="useResource") RenderCommandEncoder_useResource :: #force_inline proc(self: ^RenderCommandEncoder, resource: ^Resource, usage: ResourceUsage) { msgSend(nil, self, "useResource:usage:", resource, usage) } -@(objc_type=RenderCommandEncoder, objc_name="useResource_usage_stages_") -RenderCommandEncoder_useResource_usage_stages_ :: #force_inline proc(self: ^RenderCommandEncoder, resource: ^Resource, usage: ResourceUsage, stages: RenderStages) { +@(objc_type=RenderCommandEncoder, objc_name="useResourceWithStages") +RenderCommandEncoder_useResourceWithStages :: #force_inline proc(self: ^RenderCommandEncoder, resource: ^Resource, usage: ResourceUsage, stages: RenderStages) { msgSend(nil, self, "useResource:usage:stages:", resource, usage, stages) } @(objc_type=RenderCommandEncoder, objc_name="useResources") RenderCommandEncoder_useResources :: #force_inline proc(self: ^RenderCommandEncoder, resources: [^]^Resource, count: NS.UInteger, usage: ResourceUsage) { msgSend(nil, self, "useResources:count:usage:", resources, count, usage) } -@(objc_type=RenderCommandEncoder, objc_name="useResources_count_usage_stages_") -RenderCommandEncoder_useResources_count_usage_stages_ :: #force_inline proc(self: ^RenderCommandEncoder, resources: [^]^Resource, count: NS.UInteger, usage: ResourceUsage, stages: RenderStages) { +@(objc_type=RenderCommandEncoder, objc_name="useResourcesStages") +RenderCommandEncoder_useResourcesStages :: #force_inline proc(self: ^RenderCommandEncoder, resources: [^]^Resource, count: NS.UInteger, usage: ResourceUsage, stages: RenderStages) { msgSend(nil, self, "useResources:count:usage:stages:", resources, count, usage, stages) } @(objc_type=RenderCommandEncoder, objc_name="waitForFence") @@ -7848,18 +7848,18 @@ Methods: waitForFence */ @(objc_class="MTLResourceStateCommandEncoder") -ResourceStateCommandEncoder :: struct { using _: NS.Object } +ResourceStateCommandEncoder :: struct { using _: CommandEncoder } @(objc_type=ResourceStateCommandEncoder, objc_name="updateFence") ResourceStateCommandEncoder_updateFence :: #force_inline proc(self: ^ResourceStateCommandEncoder, fence: ^Fence) { msgSend(nil, self, "updateFence:", fence) } -@(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMapping_mode_indirectBuffer_indirectBufferOffset_") -ResourceStateCommandEncoder_updateTextureMapping_mode_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^ResourceStateCommandEncoder, texture: ^Texture, mode: SparseTextureMappingMode, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { +@(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMappingIndirect") +ResourceStateCommandEncoder_updateTextureMappingIndirect :: #force_inline proc(self: ^ResourceStateCommandEncoder, texture: ^Texture, mode: SparseTextureMappingMode, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "updateTextureMapping:mode:indirectBuffer:indirectBufferOffset:", texture, mode, indirectBuffer, indirectBufferOffset) } -@(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMapping_mode_region_mipLevel_slice_") -ResourceStateCommandEncoder_updateTextureMapping_mode_region_mipLevel_slice_ :: #force_inline proc(self: ^ResourceStateCommandEncoder, texture: ^Texture, mode: SparseTextureMappingMode, region: Region, mipLevel: NS.UInteger, slice: NS.UInteger) { +@(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMapping") +ResourceStateCommandEncoder_updateTextureMapping :: #force_inline proc(self: ^ResourceStateCommandEncoder, texture: ^Texture, mode: SparseTextureMappingMode, region: Region, mipLevel: NS.UInteger, slice: NS.UInteger) { msgSend(nil, self, "updateTextureMapping:mode:region:mipLevel:slice:", texture, mode, region, mipLevel, slice) } @(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMappings") @@ -7906,7 +7906,7 @@ Methods: signaledValue */ @(objc_class="MTLSharedEvent") -SharedEvent :: struct { using _: NS.Object } +SharedEvent :: struct { using _: Event } @(objc_type=SharedEvent, objc_name="newSharedEventHandle") SharedEvent_newSharedEventHandle :: #force_inline proc(self: ^SharedEvent) -> ^SharedEventHandle { From 8966294823d7397abaa639f37f55f26496466ba3 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Sat, 12 Feb 2022 22:03:15 +0000 Subject: [PATCH 21/64] Correct method name --- core/sys/darwin/Metal/MetalClasses.odin | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 159cc723b..26e5e2452 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -6051,7 +6051,7 @@ Methods: newRenderPipelineStateWithDescriptor newRenderPipelineStateWithTileDescriptor newRenderPipelineStateWithTileDescriptor - newSamplerStateWithDescriptor + newSamplerState newSharedEvent newSharedEventWithHandle newSharedTextureWithDescriptor @@ -6357,9 +6357,9 @@ Device_newRenderPipelineStateWithTileDescriptorWithReflection :: #force_inline p device = msgSend(^Device, self, "newRenderPipelineStateWithTileDescriptor:options:reflection:error:", descriptor, options, reflection, &error) return } -@(objc_type=Device, objc_name="newSamplerStateWithDescriptor") -Device_newSamplerStateWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^SamplerDescriptor) -> ^Device { - return msgSend(^Device, self, "newSamplerStateWithDescriptor:", descriptor) +@(objc_type=Device, objc_name="newSamplerState") +Device_newSamplerState :: #force_inline proc(self: ^Device, descriptor: ^SamplerDescriptor) -> ^Device { + return msgSend(^Device, self, "newSamplerState:", descriptor) } @(objc_type=Device, objc_name="newSharedEvent") Device_newSharedEvent :: #force_inline proc(self: ^Device) -> ^Device { From 41854bacf57ee8859bf2d55a9c74f48f8b588b26 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Sun, 13 Feb 2022 11:54:40 +0000 Subject: [PATCH 22/64] Add utility classes for dealing with Windows Most for GLFW and SDL only --- core/sys/darwin/Foundation/NSWindow.odin | 41 ++++++++++++++++ core/sys/darwin/QuartzCore/QuartzCore.odin | 54 ++++++++++++++++++++++ 2 files changed, 95 insertions(+) create mode 100644 core/sys/darwin/Foundation/NSWindow.odin create mode 100644 core/sys/darwin/QuartzCore/QuartzCore.odin diff --git a/core/sys/darwin/Foundation/NSWindow.odin b/core/sys/darwin/Foundation/NSWindow.odin new file mode 100644 index 000000000..014550aa5 --- /dev/null +++ b/core/sys/darwin/Foundation/NSWindow.odin @@ -0,0 +1,41 @@ +package objc_Foundation + +import NS "core:sys/darwin/Foundation" + +@(objc_class="CALayer") +Layer :: struct { using _: NS.Object } + +@(objc_class="NSResponder") +Responder :: struct {using _: Object} + +@(objc_class="NSView") +View :: struct {using _: Responder} + +@(objc_class="NSWindow") +Window :: struct {using _: Responder} + +@(objc_type=Window, objc_name="contentView") +Window_contentView :: proc(self: ^Window) -> ^View { + return msgSend(^View, self, "contentView") +} + +@(objc_type=View, objc_name="layer") +View_layer :: proc(self: ^View) -> ^Layer { + return msgSend(^Layer, self, "layer") +} + +@(objc_type=View, objc_name="setLayer") +View_setLayer :: proc(self: ^View, layer: ^Layer) { + msgSend(nil, self, "setLayer:", layer) +} + + +@(objc_type=View, objc_name="wantsLayer") +View_wantsLayer :: proc(self: ^View) -> BOOL { + return msgSend(BOOL, self, "wantsLayer") +} + +@(objc_type=View, objc_name="setWantsLayer") +View_setWantsLayer :: proc(self: ^View, wantsLayer: BOOL) { + msgSend(nil, self, "setWantsLayer:", wantsLayer) +} diff --git a/core/sys/darwin/QuartzCore/QuartzCore.odin b/core/sys/darwin/QuartzCore/QuartzCore.odin new file mode 100644 index 000000000..49ed51622 --- /dev/null +++ b/core/sys/darwin/QuartzCore/QuartzCore.odin @@ -0,0 +1,54 @@ +package objc_QuartzCore + +import NS "core:sys/darwin/Foundation" +import MTL "core:sys/darwin/Metal" +import "core:intrinsics" + +@(private) +msgSend :: intrinsics.objc_send + +@(objc_class="CAMetalLayer") +MetalLayer :: struct{ using _: NS.Layer} + +@(objc_type=MetalLayer, objc_name="device") +MetalLayer_device :: proc(self: ^MetalLayer) -> ^MTL.Device { + return msgSend(^MTL.Device, self, "device") +} +@(objc_type=MetalLayer, objc_name="setDevice") +MetalLayer_setDevice :: proc(self: ^MetalLayer, device: ^MTL.Device) { + msgSend(nil, self, "setDevice:", device) +} + +@(objc_type=MetalLayer, objc_name="opaque") +MetalLayer_opaque :: proc(self: ^MetalLayer) -> NS.BOOL { + return msgSend(NS.BOOL, self, "opaque") +} +@(objc_type=MetalLayer, objc_name="setOpaque") +MetalLayer_setOpaque :: proc(self: ^MetalLayer, opaque: NS.BOOL) { + msgSend(nil, self, "setOpaque:", opaque) +} + +@(objc_type=MetalLayer, objc_name="preferredDevice") +MetalLayer_preferredDevice :: proc(self: ^MetalLayer) -> ^MTL.Device { + return msgSend(^MTL.Device, self, "preferredDevice") +} +@(objc_type=MetalLayer, objc_name="pixelFormat") +MetalLayer_pixelFormat :: proc(self: ^MetalLayer) -> MTL.PixelFormat { + return msgSend(MTL.PixelFormat, self, "pixelFormat") +} +@(objc_type=MetalLayer, objc_name="framebufferOnly") +MetalLayer_framebufferOnly :: proc(self: ^MetalLayer) -> NS.BOOL { + return msgSend(NS.BOOL, self, "framebufferOnly") +} + + +@(objc_class="CAMetalDrawable") +MetalDrawable :: struct { using _: MTL.Drawable } + +MetalDrawable_layer :: proc(self: ^MetalDrawable) -> ^MetalLayer { + return msgSend(^MetalLayer, self, "layer") +} + +MetalDrawable_texture :: proc(self: ^MetalDrawable) -> ^MTL.Texture { + return msgSend(^MTL.Texture, self, "texture") +} \ No newline at end of file From 88b1b2c629cd425c8215718e40a252b78a62b34e Mon Sep 17 00:00:00 2001 From: gingerBill Date: Sun, 13 Feb 2022 15:11:45 +0000 Subject: [PATCH 23/64] Correct types --- core/sys/darwin/Foundation/NSWindow.odin | 19 +- core/sys/darwin/Metal/MetalClasses.odin | 196 ++++++++++----------- core/sys/darwin/QuartzCore/QuartzCore.odin | 33 ++++ 3 files changed, 149 insertions(+), 99 deletions(-) diff --git a/core/sys/darwin/Foundation/NSWindow.odin b/core/sys/darwin/Foundation/NSWindow.odin index 014550aa5..0c64cc8c7 100644 --- a/core/sys/darwin/Foundation/NSWindow.odin +++ b/core/sys/darwin/Foundation/NSWindow.odin @@ -2,6 +2,11 @@ package objc_Foundation import NS "core:sys/darwin/Foundation" +Rect :: struct { + x, y: f64, + width, height: f64, +} + @(objc_class="CALayer") Layer :: struct { using _: NS.Object } @@ -19,6 +24,19 @@ Window_contentView :: proc(self: ^Window) -> ^View { return msgSend(^View, self, "contentView") } +@(objc_type=Window, objc_name="frame") +Window_frame :: proc(self: ^Window) -> Rect { + return msgSend(Rect, self, "frame") +} + +@(objc_type=Window, objc_name="setFrame") +Window_setFrame :: proc(self: ^Window, frame: Rect) { + msgSend(nil, self, "setFrame:", frame) +} + + + + @(objc_type=View, objc_name="layer") View_layer :: proc(self: ^View) -> ^Layer { return msgSend(^Layer, self, "layer") @@ -29,7 +47,6 @@ View_setLayer :: proc(self: ^View, layer: ^Layer) { msgSend(nil, self, "setLayer:", layer) } - @(objc_type=View, objc_name="wantsLayer") View_wantsLayer :: proc(self: ^View) -> BOOL { return msgSend(BOOL, self, "wantsLayer") diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 26e5e2452..f2652d19b 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -2666,8 +2666,8 @@ RenderPassColorAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^Rende RenderPassColorAttachmentDescriptorArray_init :: #force_inline proc(self: ^RenderPassColorAttachmentDescriptorArray) -> ^RenderPassColorAttachmentDescriptorArray { return msgSend(^RenderPassColorAttachmentDescriptorArray, self, "init") } -@(objc_type=RenderPassColorAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -RenderPassColorAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RenderPassColorAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^RenderPassColorAttachmentDescriptor { +@(objc_type=RenderPassColorAttachmentDescriptorArray, objc_name="object") +RenderPassColorAttachmentDescriptorArray_object :: #force_inline proc(self: ^RenderPassColorAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^RenderPassColorAttachmentDescriptor { return msgSend(^RenderPassColorAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=RenderPassColorAttachmentDescriptorArray, objc_name="setObject") @@ -5375,8 +5375,8 @@ CommandBuffer_GPUStartTime :: #force_inline proc(self: ^CommandBuffer) -> CFTime return msgSend(CFTimeInterval, self, "GPUStartTime") } @(objc_type=CommandBuffer, objc_name="accelerationStructureCommandEncoder") -CommandBuffer_accelerationStructureCommandEncoder :: #force_inline proc(self: ^CommandBuffer) -> ^CommandBuffer { - return msgSend(^CommandBuffer, self, "accelerationStructureCommandEncoder") +CommandBuffer_accelerationStructureCommandEncoder :: #force_inline proc(self: ^CommandBuffer) -> ^AccelerationStructureCommandEncoder { + return msgSend(^AccelerationStructureCommandEncoder, self, "accelerationStructureCommandEncoder") } @(objc_type=CommandBuffer, objc_name="addCompletedHandler") CommandBuffer_addCompletedHandler :: #force_inline proc(self: ^CommandBuffer, block: CommandBufferHandler) { @@ -5387,32 +5387,32 @@ CommandBuffer_addScheduledHandler :: #force_inline proc(self: ^CommandBuffer, bl msgSend(nil, self, "addScheduledHandler:", block) } @(objc_type=CommandBuffer, objc_name="blitCommandEncoder") -CommandBuffer_blitCommandEncoder :: #force_inline proc(self: ^CommandBuffer) -> ^CommandBuffer { - return msgSend(^CommandBuffer, self, "blitCommandEncoder") +CommandBuffer_blitCommandEncoder :: #force_inline proc(self: ^CommandBuffer) -> ^BlitCommandEncoder { + return msgSend(^BlitCommandEncoder, self, "blitCommandEncoder") } @(objc_type=CommandBuffer, objc_name="blitCommandEncoderWithDescriptor") -CommandBuffer_blitCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, blitPassDescriptor: ^BlitPassDescriptor) -> ^CommandBuffer { - return msgSend(^CommandBuffer, self, "blitCommandEncoderWithDescriptor:", blitPassDescriptor) +CommandBuffer_blitCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, blitPassDescriptor: ^BlitPassDescriptor) -> ^BlitCommandEncoder { + return msgSend(^BlitCommandEncoder, self, "blitCommandEncoderWithDescriptor:", blitPassDescriptor) } @(objc_type=CommandBuffer, objc_name="commandQueue") -CommandBuffer_commandQueue :: #force_inline proc(self: ^CommandBuffer) -> ^CommandBuffer { - return msgSend(^CommandBuffer, self, "commandQueue") +CommandBuffer_commandQueue :: #force_inline proc(self: ^CommandBuffer) -> ^CommandQueue { + return msgSend(^CommandQueue, self, "commandQueue") } @(objc_type=CommandBuffer, objc_name="commit") CommandBuffer_commit :: #force_inline proc(self: ^CommandBuffer) { msgSend(nil, self, "commit") } @(objc_type=CommandBuffer, objc_name="computeCommandEncoder") -CommandBuffer_computeCommandEncoder :: #force_inline proc(self: ^CommandBuffer) -> ^CommandBuffer { - return msgSend(^CommandBuffer, self, "computeCommandEncoder") +CommandBuffer_computeCommandEncoder :: #force_inline proc(self: ^CommandBuffer) -> ^CommandEncoder { + return msgSend(^CommandEncoder, self, "computeCommandEncoder") } @(objc_type=CommandBuffer, objc_name="computeCommandEncoderWithDescriptor") -CommandBuffer_computeCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, computePassDescriptor: ^ComputePassDescriptor) -> ^CommandBuffer { - return msgSend(^CommandBuffer, self, "computeCommandEncoderWithDescriptor:", computePassDescriptor) +CommandBuffer_computeCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, computePassDescriptor: ^ComputePassDescriptor) -> ^CommandEncoder { + return msgSend(^CommandEncoder, self, "computeCommandEncoderWithDescriptor:", computePassDescriptor) } @(objc_type=CommandBuffer, objc_name="computeCommandEncoderWithDispatchType") -CommandBuffer_computeCommandEncoderWithDispatchType :: #force_inline proc(self: ^CommandBuffer, dispatchType: DispatchType) -> ^CommandBuffer { - return msgSend(^CommandBuffer, self, "computeCommandEncoderWithDispatchType:", dispatchType) +CommandBuffer_computeCommandEncoderWithDispatchType :: #force_inline proc(self: ^CommandBuffer, dispatchType: DispatchType) -> ^CommandEncoder { + return msgSend(^CommandEncoder, self, "computeCommandEncoderWithDispatchType:", dispatchType) } @(objc_type=CommandBuffer, objc_name="device") CommandBuffer_device :: #force_inline proc(self: ^CommandBuffer) -> ^CommandBuffer { @@ -5451,12 +5451,12 @@ CommandBuffer_label :: #force_inline proc(self: ^CommandBuffer) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=CommandBuffer, objc_name="logs") -CommandBuffer_logs :: #force_inline proc(self: ^CommandBuffer) -> ^CommandBuffer { - return msgSend(^CommandBuffer, self, "logs") +CommandBuffer_logs :: #force_inline proc(self: ^CommandBuffer) -> id { + return msgSend(id, self, "logs") } @(objc_type=CommandBuffer, objc_name="parallelRenderCommandEncoderWithDescriptor") -CommandBuffer_parallelRenderCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, renderPassDescriptor: ^RenderPassDescriptor) -> ^CommandBuffer { - return msgSend(^CommandBuffer, self, "parallelRenderCommandEncoderWithDescriptor:", renderPassDescriptor) +CommandBuffer_parallelRenderCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, renderPassDescriptor: ^RenderPassDescriptor) -> ^ParallelRenderCommandEncoder { + return msgSend(^ParallelRenderCommandEncoder, self, "parallelRenderCommandEncoderWithDescriptor:", renderPassDescriptor) } @(objc_type=CommandBuffer, objc_name="popDebugGroup") CommandBuffer_popDebugGroup :: #force_inline proc(self: ^CommandBuffer) { @@ -5479,16 +5479,16 @@ CommandBuffer_pushDebugGroup :: #force_inline proc(self: ^CommandBuffer, string: msgSend(nil, self, "pushDebugGroup:", string) } @(objc_type=CommandBuffer, objc_name="renderCommandEncoderWithDescriptor") -CommandBuffer_renderCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, renderPassDescriptor: ^RenderPassDescriptor) -> ^CommandBuffer { - return msgSend(^CommandBuffer, self, "renderCommandEncoderWithDescriptor:", renderPassDescriptor) +CommandBuffer_renderCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, renderPassDescriptor: ^RenderPassDescriptor) -> ^RenderCommandEncoder { + return msgSend(^RenderCommandEncoder, self, "renderCommandEncoderWithDescriptor:", renderPassDescriptor) } @(objc_type=CommandBuffer, objc_name="resourceStateCommandEncoder") CommandBuffer_resourceStateCommandEncoder :: #force_inline proc(self: ^CommandBuffer) -> ^CommandBuffer { return msgSend(^CommandBuffer, self, "resourceStateCommandEncoder") } @(objc_type=CommandBuffer, objc_name="resourceStateCommandEncoderWithDescriptor") -CommandBuffer_resourceStateCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, resourceStatePassDescriptor: ^ResourceStatePassDescriptor) -> ^CommandBuffer { - return msgSend(^CommandBuffer, self, "resourceStateCommandEncoderWithDescriptor:", resourceStatePassDescriptor) +CommandBuffer_resourceStateCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, resourceStatePassDescriptor: ^ResourceStatePassDescriptor) -> ^ResourceStateCommandEncoder { + return msgSend(^ResourceStateCommandEncoder, self, "resourceStateCommandEncoderWithDescriptor:", resourceStatePassDescriptor) } @(objc_type=CommandBuffer, objc_name="retainedReferences") CommandBuffer_retainedReferences :: #force_inline proc(self: ^CommandBuffer) -> BOOL { @@ -5604,8 +5604,8 @@ Methods: CommandQueue :: struct { using _: NS.Object } @(objc_type=CommandQueue, objc_name="commandBuffer") -CommandQueue_commandBuffer :: #force_inline proc(self: ^CommandQueue) -> ^CommandQueue { - return msgSend(^CommandQueue, self, "commandBuffer") +CommandQueue_commandBuffer :: #force_inline proc(self: ^CommandQueue) -> ^CommandBuffer { + return msgSend(^CommandBuffer, self, "commandBuffer") } @(objc_type=CommandQueue, objc_name="commandBufferWithDescriptor") CommandQueue_commandBufferWithDescriptor :: #force_inline proc(self: ^CommandQueue, descriptor: ^CommandBufferDescriptor) -> ^CommandQueue { @@ -5616,8 +5616,8 @@ CommandQueue_commandBufferWithUnretainedReferences :: #force_inline proc(self: ^ return msgSend(^CommandQueue, self, "commandBufferWithUnretainedReferences") } @(objc_type=CommandQueue, objc_name="device") -CommandQueue_device :: #force_inline proc(self: ^CommandQueue) -> ^CommandQueue { - return msgSend(^CommandQueue, self, "device") +CommandQueue_device :: #force_inline proc(self: ^CommandQueue) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=CommandQueue, objc_name="insertDebugCaptureBoundary") CommandQueue_insertDebugCaptureBoundary :: #force_inline proc(self: ^CommandQueue) { @@ -6195,41 +6195,41 @@ Device_name :: #force_inline proc(self: ^Device) -> ^NS.String { return msgSend(^NS.String, self, "name") } @(objc_type=Device, objc_name="newAccelerationStructureWithDescriptor") -Device_newAccelerationStructureWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^AccelerationStructureDescriptor) -> ^Device { - return msgSend(^Device, self, "newAccelerationStructureWithDescriptor:", descriptor) +Device_newAccelerationStructureWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^AccelerationStructureDescriptor) -> ^AccelerationStructure { + return msgSend(^AccelerationStructure, self, "newAccelerationStructureWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newAccelerationStructureWithSize") -Device_newAccelerationStructureWithSize :: #force_inline proc(self: ^Device, size: NS.UInteger) -> ^Device { - return msgSend(^Device, self, "newAccelerationStructureWithSize:", size) +Device_newAccelerationStructureWithSize :: #force_inline proc(self: ^Device, size: NS.UInteger) -> ^AccelerationStructure { + return msgSend(^AccelerationStructure, self, "newAccelerationStructureWithSize:", size) } @(objc_type=Device, objc_name="newArgumentEncoderWithArguments") -Device_newArgumentEncoderWithArguments :: #force_inline proc(self: ^Device, arguments: ^NS.Array) -> ^Device { - return msgSend(^Device, self, "newArgumentEncoderWithArguments:", arguments) +Device_newArgumentEncoderWithArguments :: #force_inline proc(self: ^Device, arguments: ^NS.Array) -> ^ArgumentEncoder { + return msgSend(^ArgumentEncoder, self, "newArgumentEncoderWithArguments:", arguments) } @(objc_type=Device, objc_name="newBinaryArchiveWithDescriptor") -Device_newBinaryArchiveWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^BinaryArchiveDescriptor) -> (device: ^Device, error: ^NS.Error) { - device = msgSend(^Device, self, "newBinaryArchiveWithDescriptor:error:", descriptor, &error) +Device_newBinaryArchiveWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^BinaryArchiveDescriptor) -> (res: ^BinaryArchive, error: ^NS.Error) { + res = msgSend(^BinaryArchive, self, "newBinaryArchiveWithDescriptor:error:", descriptor, &error) return } @(objc_type=Device, objc_name="newBufferWithBytes") -Device_newBufferWithBytes :: #force_inline proc(self: ^Device, pointer: rawptr, length: NS.UInteger, options: ResourceOptions) -> ^Device { - return msgSend(^Device, self, "newBufferWithBytes:length:options:", pointer, length, options) +Device_newBufferWithBytes :: #force_inline proc(self: ^Device, pointer: rawptr, length: NS.UInteger, options: ResourceOptions) -> ^Buffer { + return msgSend(^Buffer, self, "newBufferWithBytes:length:options:", pointer, length, options) } @(objc_type=Device, objc_name="newBufferWithBytesNoCopy") -Device_newBufferWithBytesNoCopy :: #force_inline proc(self: ^Device, pointer: rawptr, length: NS.UInteger, options: ResourceOptions, deallocator: rawptr) -> ^Device { - return msgSend(^Device, self, "newBufferWithBytesNoCopy:length:options:deallocator:", pointer, length, options, deallocator) +Device_newBufferWithBytesNoCopy :: #force_inline proc(self: ^Device, pointer: rawptr, length: NS.UInteger, options: ResourceOptions, deallocator: rawptr) -> ^Buffer { + return msgSend(^Buffer, self, "newBufferWithBytesNoCopy:length:options:deallocator:", pointer, length, options, deallocator) } @(objc_type=Device, objc_name="newBufferWithLength") -Device_newBufferWithLength :: #force_inline proc(self: ^Device, length: NS.UInteger, options: ResourceOptions) -> ^Device { - return msgSend(^Device, self, "newBufferWithLength:options:", length, options) +Device_newBufferWithLength :: #force_inline proc(self: ^Device, length: NS.UInteger, options: ResourceOptions) -> ^Buffer { + return msgSend(^Buffer, self, "newBufferWithLength:options:", length, options) } @(objc_type=Device, objc_name="newCommandQueue") -Device_newCommandQueue :: #force_inline proc(self: ^Device) -> ^Device { - return msgSend(^Device, self, "newCommandQueue") +Device_newCommandQueue :: #force_inline proc(self: ^Device) -> ^CommandQueue { + return msgSend(^CommandQueue, self, "newCommandQueue") } @(objc_type=Device, objc_name="newCommandQueueWithMaxCommandBufferCount") -Device_newCommandQueueWithMaxCommandBufferCount :: #force_inline proc(self: ^Device, maxCommandBufferCount: NS.UInteger) -> ^Device { - return msgSend(^Device, self, "newCommandQueueWithMaxCommandBufferCount:", maxCommandBufferCount) +Device_newCommandQueueWithMaxCommandBufferCount :: #force_inline proc(self: ^Device, maxCommandBufferCount: NS.UInteger) -> ^CommandQueue { + 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) { @@ -6245,8 +6245,8 @@ Device_newComputePipelineStateWithFunctionWithCompletionHandler :: #force_inline msgSend(nil, self, "newComputePipelineStateWithFunction:completionHandler:", computeFunction, completionHandler) } @(objc_type=Device, objc_name="newComputePipelineStateWithFunction") -Device_newComputePipelineStateWithFunction :: #force_inline proc(self: ^Device, computeFunction: ^Function) -> (device: ^Device, error: ^NS.Error) { - device = msgSend(^Device, self, "newComputePipelineStateWithFunction:error:", computeFunction, &error) +Device_newComputePipelineStateWithFunction :: #force_inline proc(self: ^Device, computeFunction: ^Function) -> (res: ^Device, error: ^NS.Error) { + res = msgSend(^Device, self, "newComputePipelineStateWithFunction:error:", computeFunction, &error) return } @(objc_type=Device, objc_name="newComputePipelineStateWithFunctionWithOptionsAndCompletionHandler") @@ -6264,79 +6264,79 @@ Device_newCounterSampleBufferWithDescriptor :: #force_inline proc(self: ^Device, return } @(objc_type=Device, objc_name="newDefaultLibrary") -Device_newDefaultLibrary :: #force_inline proc(self: ^Device) -> ^Device { - return msgSend(^Device, self, "newDefaultLibrary") +Device_newDefaultLibrary :: #force_inline proc(self: ^Device) -> ^Library { + return msgSend(^Library, self, "newDefaultLibrary") } @(objc_type=Device, objc_name="newDefaultLibraryWithBundle") -Device_newDefaultLibraryWithBundle :: #force_inline proc(self: ^Device, bundle: ^NS.Bundle) -> (device: ^Device, error: ^NS.Error) { - device = msgSend(^Device, self, "newDefaultLibraryWithBundle:error:", bundle, &error) +Device_newDefaultLibraryWithBundle :: #force_inline proc(self: ^Device, bundle: ^NS.Bundle) -> (library: ^Library, error: ^NS.Error) { + library = msgSend(^Library, self, "newDefaultLibraryWithBundle:error:", bundle, &error) return } @(objc_type=Device, objc_name="newDepthStencilStateWithDescriptor") -Device_newDepthStencilStateWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^DepthStencilDescriptor) -> ^Device { - return msgSend(^Device, self, "newDepthStencilStateWithDescriptor:", descriptor) +Device_newDepthStencilStateWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^DepthStencilDescriptor) -> ^DepthStencilState { + return msgSend(^DepthStencilState, self, "newDepthStencilStateWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newDynamicLibrary") -Device_newDynamicLibrary :: #force_inline proc(self: ^Device, library: ^Library) -> (device: ^Device, error: ^NS.Error) { - device = msgSend(^Device, self, "newDynamicLibrary:error:", library, &error) +Device_newDynamicLibrary :: #force_inline proc(self: ^Device, library: ^Library) -> (dyn_library: ^DynamicLibrary, error: ^NS.Error) { + dyn_library = msgSend(^DynamicLibrary, self, "newDynamicLibrary:error:", library, &error) return } @(objc_type=Device, objc_name="newDynamicLibraryWithURL") -Device_newDynamicLibraryWithURL :: #force_inline proc(self: ^Device, url: ^NS.URL) -> (device: ^Device, error: ^NS.Error) { - device = msgSend(^Device, self, "newDynamicLibraryWithURL:error:", url, &error) +Device_newDynamicLibraryWithURL :: #force_inline proc(self: ^Device, url: ^NS.URL) -> (dyn_library: ^DynamicLibrary, error: ^NS.Error) { + dyn_library = msgSend(^DynamicLibrary, self, "newDynamicLibraryWithURL:error:", url, &error) return } @(objc_type=Device, objc_name="newEvent") -Device_newEvent :: #force_inline proc(self: ^Device) -> ^Device { - return msgSend(^Device, self, "newEvent") +Device_newEvent :: #force_inline proc(self: ^Device) -> ^Event { + return msgSend(^Event, self, "newEvent") } @(objc_type=Device, objc_name="newFence") -Device_newFence :: #force_inline proc(self: ^Device) -> ^Device { - return msgSend(^Device, self, "newFence") +Device_newFence :: #force_inline proc(self: ^Device) -> ^Fence { + return msgSend(^Fence, self, "newFence") } @(objc_type=Device, objc_name="newHeapWithDescriptor") -Device_newHeapWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^HeapDescriptor) -> ^Device { - return msgSend(^Device, self, "newHeapWithDescriptor:", descriptor) +Device_newHeapWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^HeapDescriptor) -> ^Heap { + return msgSend(^Heap, self, "newHeapWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newIndirectCommandBufferWithDescriptor") -Device_newIndirectCommandBufferWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^IndirectCommandBufferDescriptor, maxCount: NS.UInteger, options: ResourceOptions) -> ^Device { - return msgSend(^Device, self, "newIndirectCommandBufferWithDescriptor:maxCommandCount:options:", descriptor, maxCount, options) +Device_newIndirectCommandBufferWithDescriptor :: #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) -> (device: ^Device, error: ^NS.Error) { - device = msgSend(^Device, self, "newLibraryWithData:error:", data, &error) +Device_newLibraryWithData :: #force_inline proc(self: ^Device, data: dispatch_data_t) -> (library: ^Library, error: ^NS.Error) { + library = msgSend(^Library, self, "newLibraryWithData:error:", data, &error) return } @(objc_type=Device, objc_name="newLibraryWithFile") -Device_newLibraryWithFile :: #force_inline proc(self: ^Device, filepath: ^NS.String) -> (device: ^Device, error: ^NS.Error) { - device = msgSend(^Device, self, "newLibraryWithFile:error:", filepath, &error) +Device_newLibraryWithFile :: #force_inline proc(self: ^Device, filepath: ^NS.String) -> (library: ^Library, error: ^NS.Error) { + library = msgSend(^Library, self, "newLibraryWithFile:error:", filepath, &error) return } @(objc_type=Device, objc_name="newLibraryWithSourceWithCompletionHandler") -Device_newLibraryWithSourceWithCompletionHandler :: #force_inline proc(self: ^Device, source: ^NS.String, options: ^CompileOptions, completionHandler: NewLibraryCompletionHandler) { - msgSend(nil, self, "newLibraryWithSource:options:completionHandler:", source, options, completionHandler) +Device_newLibraryWithSourceWithCompletionHandler :: #force_inline proc(self: ^Device, source: ^NS.String, options: ^CompileOptions, completionHandler: NewLibraryCompletionHandler) -> ^Library { + return msgSend(^Library, self, "newLibraryWithSource:options:completionHandler:", source, options, completionHandler) } @(objc_type=Device, objc_name="newLibraryWithSource") -Device_newLibraryWithSource :: #force_inline proc(self: ^Device, source: ^NS.String, options: ^CompileOptions) -> (device: ^Device, error: ^NS.Error) { - device = msgSend(^Device, self, "newLibraryWithSource:options:error:", source, options, &error) +Device_newLibraryWithSource :: #force_inline proc(self: ^Device, source: ^NS.String, options: ^CompileOptions) -> (library: ^Library, error: ^NS.Error) { + library = msgSend(^Library, self, "newLibraryWithSource:options:error:", source, options, &error) return } @(objc_type=Device, objc_name="newLibraryWithURL") -Device_newLibraryWithURL :: #force_inline proc(self: ^Device, url: ^NS.URL) -> (device: ^Device, error: ^NS.Error) { - device = msgSend(^Device, self, "newLibraryWithURL:error:", url, &error) +Device_newLibraryWithURL :: #force_inline proc(self: ^Device, url: ^NS.URL) -> (library: ^Library, error: ^NS.Error) { + library = msgSend(^Library, self, "newLibraryWithURL:error:", url, &error) return } @(objc_type=Device, objc_name="newRasterizationRateMapWithDescriptor") -Device_newRasterizationRateMapWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^RasterizationRateMapDescriptor) -> ^Device { - return msgSend(^Device, self, "newRasterizationRateMapWithDescriptor:", descriptor) +Device_newRasterizationRateMapWithDescriptor :: #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) { msgSend(nil, self, "newRenderPipelineStateWithDescriptor:completionHandler:", descriptor, completionHandler) } @(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor") -Device_newRenderPipelineStateWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor) -> (device: ^Device, error: ^NS.Error) { - device = msgSend(^Device, self, "newRenderPipelineStateWithDescriptor:error:", descriptor, &error) +Device_newRenderPipelineStateWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor) -> (pipeline: ^RenderPipelineState, error: ^NS.Error) { + pipeline = msgSend(^RenderPipelineState, self, "newRenderPipelineStateWithDescriptor:error:", descriptor, &error) return } @(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptorWithOptionsAndCompletionHandler") @@ -6344,8 +6344,8 @@ Device_newRenderPipelineStateWithDescriptorWithOptionsAndCompletionHandler :: #f msgSend(nil, self, "newRenderPipelineStateWithDescriptor:options:completionHandler:", descriptor, options, completionHandler) } @(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptorWithReflection") -Device_newRenderPipelineStateWithDescriptorWithReflection :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection) -> (device: ^Device, error: ^NS.Error) { - device = msgSend(^Device, self, "newRenderPipelineStateWithDescriptor:options:reflection:error:", descriptor, options, reflection, &error) +Device_newRenderPipelineStateWithDescriptorWithReflection :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection) -> (pipeline: ^RenderPipelineState, error: ^NS.Error) { + pipeline = msgSend(^RenderPipelineState, self, "newRenderPipelineStateWithDescriptor:options:reflection:error:", descriptor, options, reflection, &error) return } @(objc_type=Device, objc_name="newRenderPipelineStateWithTileDescriptorWithCompletionHandler") @@ -6353,37 +6353,37 @@ Device_newRenderPipelineStateWithTileDescriptorWithCompletionHandler :: #force_i msgSend(nil, self, "newRenderPipelineStateWithTileDescriptor:options:completionHandler:", descriptor, options, completionHandler) } @(objc_type=Device, objc_name="newRenderPipelineStateWithTileDescriptorWithReflection") -Device_newRenderPipelineStateWithTileDescriptorWithReflection :: #force_inline proc(self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection) -> (device: ^Device, error: ^NS.Error) { - device = msgSend(^Device, self, "newRenderPipelineStateWithTileDescriptor:options:reflection:error:", descriptor, options, reflection, &error) +Device_newRenderPipelineStateWithTileDescriptorWithReflection :: #force_inline proc(self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection) -> (pipeline: ^RenderPipelineState, error: ^NS.Error) { + pipeline = msgSend(^RenderPipelineState, self, "newRenderPipelineStateWithTileDescriptor:options:reflection:error:", descriptor, options, reflection, &error) return } @(objc_type=Device, objc_name="newSamplerState") -Device_newSamplerState :: #force_inline proc(self: ^Device, descriptor: ^SamplerDescriptor) -> ^Device { - return msgSend(^Device, self, "newSamplerState:", descriptor) +Device_newSamplerState :: #force_inline proc(self: ^Device, descriptor: ^SamplerDescriptor) -> ^SamplerState { + return msgSend(^SamplerState, self, "newSamplerState:", descriptor) } @(objc_type=Device, objc_name="newSharedEvent") -Device_newSharedEvent :: #force_inline proc(self: ^Device) -> ^Device { - return msgSend(^Device, self, "newSharedEvent") +Device_newSharedEvent :: #force_inline proc(self: ^Device) -> ^SharedEvent { + return msgSend(^SharedEvent, self, "newSharedEvent") } @(objc_type=Device, objc_name="newSharedEventWithHandle") -Device_newSharedEventWithHandle :: #force_inline proc(self: ^Device, sharedEventHandle: ^SharedEventHandle) -> ^Device { - return msgSend(^Device, self, "newSharedEventWithHandle:", sharedEventHandle) +Device_newSharedEventWithHandle :: #force_inline proc(self: ^Device, sharedEventHandle: ^SharedEventHandle) -> ^SharedEvent { + return msgSend(^SharedEvent, self, "newSharedEventWithHandle:", sharedEventHandle) } @(objc_type=Device, objc_name="newSharedTextureWithDescriptor") -Device_newSharedTextureWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^TextureDescriptor) -> ^Device { - return msgSend(^Device, self, "newSharedTextureWithDescriptor:", descriptor) +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) -> ^Device { - return msgSend(^Device, self, "newSharedTextureWithHandle:", sharedHandle) +Device_newSharedTextureWithHandle :: #force_inline proc(self: ^Device, sharedHandle: ^SharedTextureHandle) -> ^SharedEvent { + return msgSend(^SharedEvent, self, "newSharedTextureWithHandle:", sharedHandle) } @(objc_type=Device, objc_name="newTextureWithDescriptor") -Device_newTextureWithDescriptor :: #force_inline proc(self: ^Device, desc: ^TextureDescriptor) -> ^Device { - return msgSend(^Device, self, "newTextureWithDescriptor:", desc) +Device_newTextureWithDescriptor :: #force_inline proc(self: ^Device, desc: ^TextureDescriptor) -> ^SharedEvent { + return msgSend(^SharedEvent, self, "newTextureWithDescriptor:", desc) } @(objc_type=Device, objc_name="newTextureWithDescriptorWithIOSurface") -Device_newTextureWithDescriptorWithIOSurface :: #force_inline proc(self: ^Device, descriptor: ^TextureDescriptor, iosurface: IOSurfaceRef, plane: NS.UInteger) -> ^Device { - return msgSend(^Device, self, "newTextureWithDescriptor:iosurface:plane:", descriptor, iosurface, plane) +Device_newTextureWithDescriptorWithIOSurface :: #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="peerCount") Device_peerCount :: #force_inline proc(self: ^Device) -> u32 { diff --git a/core/sys/darwin/QuartzCore/QuartzCore.odin b/core/sys/darwin/QuartzCore/QuartzCore.odin index 49ed51622..0afb8aa37 100644 --- a/core/sys/darwin/QuartzCore/QuartzCore.odin +++ b/core/sys/darwin/QuartzCore/QuartzCore.odin @@ -10,6 +10,11 @@ msgSend :: intrinsics.objc_send @(objc_class="CAMetalLayer") MetalLayer :: struct{ using _: NS.Layer} +@(objc_type=MetalLayer, objc_class_name="layer") +MetalLayer_layer :: proc() -> ^MetalLayer { + return msgSend(^MetalLayer, MetalLayer, "layer") +} + @(objc_type=MetalLayer, objc_name="device") MetalLayer_device :: proc(self: ^MetalLayer) -> ^MTL.Device { return msgSend(^MTL.Device, self, "device") @@ -19,6 +24,7 @@ MetalLayer_setDevice :: proc(self: ^MetalLayer, device: ^MTL.Device) { msgSend(nil, self, "setDevice:", device) } + @(objc_type=MetalLayer, objc_name="opaque") MetalLayer_opaque :: proc(self: ^MetalLayer) -> NS.BOOL { return msgSend(NS.BOOL, self, "opaque") @@ -36,19 +42,46 @@ MetalLayer_preferredDevice :: proc(self: ^MetalLayer) -> ^MTL.Device { MetalLayer_pixelFormat :: proc(self: ^MetalLayer) -> MTL.PixelFormat { return msgSend(MTL.PixelFormat, self, "pixelFormat") } +@(objc_type=MetalLayer, objc_name="setPixelFormat") +MetalLayer_setPixelFormat :: proc(self: ^MetalLayer, pixelFormat: MTL.PixelFormat) { + msgSend(nil, self, "setPixelFormat:", pixelFormat) +} + @(objc_type=MetalLayer, objc_name="framebufferOnly") MetalLayer_framebufferOnly :: proc(self: ^MetalLayer) -> NS.BOOL { return msgSend(NS.BOOL, self, "framebufferOnly") } +@(objc_type=MetalLayer, objc_name="setFramebufferOnly") +MetalLayer_setFramebufferOnly :: proc(self: ^MetalLayer, ok: NS.BOOL) { + msgSend(nil, self, "setFramebufferOnly:", ok) +} + +@(objc_type=MetalLayer, objc_name="frame") +MetalLayer_frame :: proc(self: ^MetalLayer) -> NS.Rect { + return msgSend(NS.Rect, self, "frame") +} +@(objc_type=MetalLayer, objc_name="setFrame") +MetalLayer_setFrame :: proc(self: ^MetalLayer, frame: NS.Rect) { + msgSend(nil, self, "setFrame:", frame) +} + + +@(objc_type=MetalLayer, objc_name="nextDrawable") +MetalLayer_nextDrawable :: proc(self: ^MetalLayer) -> ^MetalDrawable { + return msgSend(^MetalDrawable, self, "nextDrawable") +} + @(objc_class="CAMetalDrawable") MetalDrawable :: struct { using _: MTL.Drawable } +@(objc_type=MetalDrawable, objc_name="layer") MetalDrawable_layer :: proc(self: ^MetalDrawable) -> ^MetalLayer { return msgSend(^MetalLayer, self, "layer") } +@(objc_type=MetalDrawable, objc_name="texture") MetalDrawable_texture :: proc(self: ^MetalDrawable) -> ^MTL.Texture { return msgSend(^MTL.Texture, self, "texture") } \ No newline at end of file From 9dc83bc1b3b9084c80eb672b6de03a039c806228 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Sun, 13 Feb 2022 16:32:31 +0000 Subject: [PATCH 24/64] Add more methods --- core/sys/darwin/Foundation/NSWindow.odin | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/core/sys/darwin/Foundation/NSWindow.odin b/core/sys/darwin/Foundation/NSWindow.odin index 0c64cc8c7..6791db4ef 100644 --- a/core/sys/darwin/Foundation/NSWindow.odin +++ b/core/sys/darwin/Foundation/NSWindow.odin @@ -7,6 +7,9 @@ Rect :: struct { width, height: f64, } +@(objc_class="NSColor") +Color :: struct {using _: Object} + @(objc_class="CALayer") Layer :: struct { using _: NS.Object } @@ -28,14 +31,29 @@ Window_contentView :: proc(self: ^Window) -> ^View { Window_frame :: proc(self: ^Window) -> Rect { return msgSend(Rect, self, "frame") } - @(objc_type=Window, objc_name="setFrame") Window_setFrame :: proc(self: ^Window, frame: Rect) { msgSend(nil, self, "setFrame:", frame) } +@(objc_type=Window, objc_name="opaque") +Window_opaque :: proc(self: ^Window) -> NS.BOOL { + return msgSend(NS.BOOL, self, "opaque") +} +@(objc_type=Window, objc_name="setOpaque") +Window_setOpaque :: proc(self: ^Window, ok: NS.BOOL) { + msgSend(nil, self, "setOpaque:", ok) +} +@(objc_type=Window, objc_name="backgroundColor") +Window_backgroundColor :: proc(self: ^Window) -> ^NS.Color { + return msgSend(^NS.Color, self, "backgroundColor") +} +@(objc_type=Window, objc_name="setBackgroundColor") +Window_setBackgroundColor :: proc(self: ^Window, color: ^NS.Color) { + msgSend(nil, self, "setBackgroundColor:", color) +} @(objc_type=View, objc_name="layer") View_layer :: proc(self: ^View) -> ^Layer { From 2958c1d6aa620221ff5896b386f3e35ca4522357 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Sun, 13 Feb 2022 16:56:27 +0000 Subject: [PATCH 25/64] Add `new` shorthand --- core/sys/darwin/Foundation/NSObject.odin | 3 ++ core/sys/darwin/Foundation/NSWindow.odin | 47 +++++++++++++----------- 2 files changed, 29 insertions(+), 21 deletions(-) diff --git a/core/sys/darwin/Foundation/NSObject.odin b/core/sys/darwin/Foundation/NSObject.odin index cd0919edd..82d837fb8 100644 --- a/core/sys/darwin/Foundation/NSObject.odin +++ b/core/sys/darwin/Foundation/NSObject.odin @@ -31,6 +31,9 @@ copy :: proc(self: ^Copying($T)) -> ^T where intrinsics.type_is_subtype_of(T, Ob return msgSend(^T, self, "copy") } +new :: proc($T: typeid) -> ^T where intrinsics.type_is_subtype_of(T, Object) { + return init(alloc(T)) +} @(objc_type=Object, objc_name="retain") retain :: proc(self: ^Object) { diff --git a/core/sys/darwin/Foundation/NSWindow.odin b/core/sys/darwin/Foundation/NSWindow.odin index 6791db4ef..e109284d1 100644 --- a/core/sys/darwin/Foundation/NSWindow.odin +++ b/core/sys/darwin/Foundation/NSWindow.odin @@ -19,6 +19,32 @@ Responder :: struct {using _: Object} @(objc_class="NSView") View :: struct {using _: Responder} +@(objc_type=View, objc_name="layer") +View_layer :: proc(self: ^View) -> ^Layer { + return msgSend(^Layer, self, "layer") +} + +@(objc_type=View, objc_name="setLayer") +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") +} + +@(objc_type=View, objc_name="setWantsLayer") +View_setWantsLayer :: proc(self: ^View, wantsLayer: BOOL) { + msgSend(nil, self, "setWantsLayer:", wantsLayer) +} + + @(objc_class="NSWindow") Window :: struct {using _: Responder} @@ -45,7 +71,6 @@ Window_setOpaque :: proc(self: ^Window, ok: NS.BOOL) { msgSend(nil, self, "setOpaque:", ok) } - @(objc_type=Window, objc_name="backgroundColor") Window_backgroundColor :: proc(self: ^Window) -> ^NS.Color { return msgSend(^NS.Color, self, "backgroundColor") @@ -54,23 +79,3 @@ Window_backgroundColor :: proc(self: ^Window) -> ^NS.Color { Window_setBackgroundColor :: proc(self: ^Window, color: ^NS.Color) { msgSend(nil, self, "setBackgroundColor:", color) } - -@(objc_type=View, objc_name="layer") -View_layer :: proc(self: ^View) -> ^Layer { - return msgSend(^Layer, self, "layer") -} - -@(objc_type=View, objc_name="setLayer") -View_setLayer :: proc(self: ^View, layer: ^Layer) { - msgSend(nil, self, "setLayer:", layer) -} - -@(objc_type=View, objc_name="wantsLayer") -View_wantsLayer :: proc(self: ^View) -> BOOL { - return msgSend(BOOL, self, "wantsLayer") -} - -@(objc_type=View, objc_name="setWantsLayer") -View_setWantsLayer :: proc(self: ^View, wantsLayer: BOOL) { - msgSend(nil, self, "setWantsLayer:", wantsLayer) -} From c34ae884ad411de4e98bad48445f6e77ef9abe2d Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 11:04:29 +0000 Subject: [PATCH 26/64] Change to "object" --- core/sys/darwin/Metal/MetalClasses.odin | 86 ++++++++++++------------- 1 file changed, 43 insertions(+), 43 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index f2652d19b..6abf923ae 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -676,8 +676,8 @@ AttributeDescriptorArray_alloc :: #force_inline proc() -> ^AttributeDescriptorAr AttributeDescriptorArray_init :: #force_inline proc(self: ^AttributeDescriptorArray) -> ^AttributeDescriptorArray { return msgSend(^AttributeDescriptorArray, self, "init") } -@(objc_type=AttributeDescriptorArray, objc_name="objectAtIndexedSubscript") -AttributeDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^AttributeDescriptorArray, index: NS.UInteger) -> ^AttributeDescriptor { +@(objc_type=AttributeDescriptorArray, objc_name="object") +AttributeDescriptorArray_object :: #force_inline proc(self: ^AttributeDescriptorArray, index: NS.UInteger) -> ^AttributeDescriptor { return msgSend(^AttributeDescriptor, self, "objectAtIndexedSubscript:", index) } @(objc_type=AttributeDescriptorArray, objc_name="setObject") @@ -824,8 +824,8 @@ BlitPassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^ BlitPassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray) -> ^BlitPassSampleBufferAttachmentDescriptorArray { return msgSend(^BlitPassSampleBufferAttachmentDescriptorArray, self, "init") } -@(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -BlitPassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^BlitPassSampleBufferAttachmentDescriptor { +@(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_name="object") +BlitPassSampleBufferAttachmentDescriptorArray_object :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^BlitPassSampleBufferAttachmentDescriptor { return msgSend(^BlitPassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_name="setObject") @@ -908,8 +908,8 @@ BufferLayoutDescriptorArray_alloc :: #force_inline proc() -> ^BufferLayoutDescri BufferLayoutDescriptorArray_init :: #force_inline proc(self: ^BufferLayoutDescriptorArray) -> ^BufferLayoutDescriptorArray { return msgSend(^BufferLayoutDescriptorArray, self, "init") } -@(objc_type=BufferLayoutDescriptorArray, objc_name="objectAtIndexedSubscript") -BufferLayoutDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^BufferLayoutDescriptorArray, index: NS.UInteger) -> ^BufferLayoutDescriptor { +@(objc_type=BufferLayoutDescriptorArray, objc_name="object") +BufferLayoutDescriptorArray_object :: #force_inline proc(self: ^BufferLayoutDescriptorArray, index: NS.UInteger) -> ^BufferLayoutDescriptor { return msgSend(^BufferLayoutDescriptor, self, "objectAtIndexedSubscript:", index) } @(objc_type=BufferLayoutDescriptorArray, objc_name="setObject") @@ -1303,8 +1303,8 @@ ComputePassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc() - ComputePassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray) -> ^ComputePassSampleBufferAttachmentDescriptorArray { return msgSend(^ComputePassSampleBufferAttachmentDescriptorArray, self, "init") } -@(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -ComputePassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^ComputePassSampleBufferAttachmentDescriptor { +@(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_name="object") +ComputePassSampleBufferAttachmentDescriptorArray_object :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^ComputePassSampleBufferAttachmentDescriptor { return msgSend(^ComputePassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_name="setObject") @@ -2178,8 +2178,8 @@ PipelineBufferDescriptorArray_alloc :: #force_inline proc() -> ^PipelineBufferDe PipelineBufferDescriptorArray_init :: #force_inline proc(self: ^PipelineBufferDescriptorArray) -> ^PipelineBufferDescriptorArray { return msgSend(^PipelineBufferDescriptorArray, self, "init") } -@(objc_type=PipelineBufferDescriptorArray, objc_name="objectAtIndexedSubscript") -PipelineBufferDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^PipelineBufferDescriptorArray, bufferIndex: NS.UInteger) -> ^PipelineBufferDescriptor { +@(objc_type=PipelineBufferDescriptorArray, objc_name="object") +PipelineBufferDescriptorArray_object :: #force_inline proc(self: ^PipelineBufferDescriptorArray, bufferIndex: NS.UInteger) -> ^PipelineBufferDescriptor { return msgSend(^PipelineBufferDescriptor, self, "objectAtIndexedSubscript:", bufferIndex) } @(objc_type=PipelineBufferDescriptorArray, objc_name="setObject") @@ -2304,8 +2304,8 @@ RasterizationRateLayerArray_alloc :: #force_inline proc() -> ^RasterizationRateL RasterizationRateLayerArray_init :: #force_inline proc(self: ^RasterizationRateLayerArray) -> ^RasterizationRateLayerArray { return msgSend(^RasterizationRateLayerArray, self, "init") } -@(objc_type=RasterizationRateLayerArray, objc_name="objectAtIndexedSubscript") -RasterizationRateLayerArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RasterizationRateLayerArray, layerIndex: NS.UInteger) -> ^RasterizationRateLayerDescriptor { +@(objc_type=RasterizationRateLayerArray, objc_name="object") +RasterizationRateLayerArray_object :: #force_inline proc(self: ^RasterizationRateLayerArray, layerIndex: NS.UInteger) -> ^RasterizationRateLayerDescriptor { return msgSend(^RasterizationRateLayerDescriptor, self, "objectAtIndexedSubscript:", layerIndex) } @(objc_type=RasterizationRateLayerArray, objc_name="setObject") @@ -2470,8 +2470,8 @@ RasterizationRateSampleArray_alloc :: #force_inline proc() -> ^RasterizationRate RasterizationRateSampleArray_init :: #force_inline proc(self: ^RasterizationRateSampleArray) -> ^RasterizationRateSampleArray { return msgSend(^RasterizationRateSampleArray, self, "init") } -@(objc_type=RasterizationRateSampleArray, objc_name="objectAtIndexedSubscript") -RasterizationRateSampleArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RasterizationRateSampleArray, index: NS.UInteger) -> NS.UInteger { +@(objc_type=RasterizationRateSampleArray, objc_name="object") +RasterizationRateSampleArray_object :: #force_inline proc(self: ^RasterizationRateSampleArray, index: NS.UInteger) -> NS.UInteger { return msgSend(NS.UInteger, self, "objectAtIndexedSubscript:", index) } @(objc_type=RasterizationRateSampleArray, objc_name="setObject") @@ -2979,8 +2979,8 @@ RenderPassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc() -> RenderPassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray) -> ^RenderPassSampleBufferAttachmentDescriptorArray { return msgSend(^RenderPassSampleBufferAttachmentDescriptorArray, self, "init") } -@(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -RenderPassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^RenderPassSampleBufferAttachmentDescriptor { +@(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_name="object") +RenderPassSampleBufferAttachmentDescriptorArray_object :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^RenderPassSampleBufferAttachmentDescriptor { return msgSend(^RenderPassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_name="setObject") @@ -3165,8 +3165,8 @@ RenderPipelineColorAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^R RenderPipelineColorAttachmentDescriptorArray_init :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptorArray) -> ^RenderPipelineColorAttachmentDescriptorArray { return msgSend(^RenderPipelineColorAttachmentDescriptorArray, self, "init") } -@(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -RenderPipelineColorAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^RenderPipelineColorAttachmentDescriptor { +@(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_name="object") +RenderPipelineColorAttachmentDescriptorArray_object :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^RenderPipelineColorAttachmentDescriptor { return msgSend(^RenderPipelineColorAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_name="setObject") @@ -3580,8 +3580,8 @@ ResourceStatePassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline pr ResourceStatePassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray) -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray { return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptorArray, self, "init") } -@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -ResourceStatePassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^ResourceStatePassSampleBufferAttachmentDescriptor { +@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_name="object") +ResourceStatePassSampleBufferAttachmentDescriptorArray_object :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^ResourceStatePassSampleBufferAttachmentDescriptor { return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_name="setObject") @@ -4374,8 +4374,8 @@ TileRenderPipelineColorAttachmentDescriptorArray_alloc :: #force_inline proc() - TileRenderPipelineColorAttachmentDescriptorArray_init :: #force_inline proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray) -> ^TileRenderPipelineColorAttachmentDescriptorArray { return msgSend(^TileRenderPipelineColorAttachmentDescriptorArray, self, "init") } -@(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript") -TileRenderPipelineColorAttachmentDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^TileRenderPipelineColorAttachmentDescriptor { +@(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_name="object") +TileRenderPipelineColorAttachmentDescriptorArray_object :: #force_inline proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^TileRenderPipelineColorAttachmentDescriptor { return msgSend(^TileRenderPipelineColorAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_name="setObject") @@ -4634,8 +4634,8 @@ VertexAttributeDescriptorArray_alloc :: #force_inline proc() -> ^VertexAttribute VertexAttributeDescriptorArray_init :: #force_inline proc(self: ^VertexAttributeDescriptorArray) -> ^VertexAttributeDescriptorArray { return msgSend(^VertexAttributeDescriptorArray, self, "init") } -@(objc_type=VertexAttributeDescriptorArray, objc_name="objectAtIndexedSubscript") -VertexAttributeDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^VertexAttributeDescriptorArray, index: NS.UInteger) -> ^VertexAttributeDescriptor { +@(objc_type=VertexAttributeDescriptorArray, objc_name="object") +VertexAttributeDescriptorArray_object :: #force_inline proc(self: ^VertexAttributeDescriptorArray, index: NS.UInteger) -> ^VertexAttributeDescriptor { return msgSend(^VertexAttributeDescriptor, self, "objectAtIndexedSubscript:", index) } @(objc_type=VertexAttributeDescriptorArray, objc_name="setObject") @@ -4718,8 +4718,8 @@ VertexBufferLayoutDescriptorArray_alloc :: #force_inline proc() -> ^VertexBuffer VertexBufferLayoutDescriptorArray_init :: #force_inline proc(self: ^VertexBufferLayoutDescriptorArray) -> ^VertexBufferLayoutDescriptorArray { return msgSend(^VertexBufferLayoutDescriptorArray, self, "init") } -@(objc_type=VertexBufferLayoutDescriptorArray, objc_name="objectAtIndexedSubscript") -VertexBufferLayoutDescriptorArray_objectAtIndexedSubscript :: #force_inline proc(self: ^VertexBufferLayoutDescriptorArray, index: NS.UInteger) -> ^VertexBufferLayoutDescriptor { +@(objc_type=VertexBufferLayoutDescriptorArray, objc_name="object") +VertexBufferLayoutDescriptorArray_object :: #force_inline proc(self: ^VertexBufferLayoutDescriptorArray, index: NS.UInteger) -> ^VertexBufferLayoutDescriptor { return msgSend(^VertexBufferLayoutDescriptor, self, "objectAtIndexedSubscript:", index) } @(objc_type=VertexBufferLayoutDescriptorArray, objc_name="setObject") @@ -7007,7 +7007,7 @@ IndirectRenderCommand_drawPatches :: #force_inline proc(self: ^IndirectRenderCom msgSend(nil, self, "drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride) } @(objc_type=IndirectRenderCommand, objc_name="drawPrimitives") -IndirectRenderCommand_drawPrimitives :: #force_inline proc(self: ^IndirectRenderCommand, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) { +IndirectRenderCommand_drawPrimitives :: #force_inline proc(self: ^IndirectRenderCommand, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger, instanceCount: NS.UInteger = 0, baseInstance: NS.UInteger = 0) { msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:", primitiveType, vertexStart, vertexCount, instanceCount, baseInstance) } @(objc_type=IndirectRenderCommand, objc_name="reset") @@ -7104,8 +7104,8 @@ Methods: Library :: struct { using _: NS.Object } @(objc_type=Library, objc_name="device") -Library_device :: #force_inline proc(self: ^Library) -> ^Library { - return msgSend(^Library, self, "device") +Library_device :: #force_inline proc(self: ^Library) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=Library, objc_name="functionNames") Library_functionNames :: #force_inline proc(self: ^Library) -> ^NS.Array { @@ -7120,34 +7120,34 @@ Library_label :: #force_inline proc(self: ^Library) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=Library, objc_name="newFunctionWithDescriptorWithCompletionHandler") -Library_newFunctionWithDescriptorWithCompletionHandler :: #force_inline proc(self: ^Library, descriptor: ^FunctionDescriptor, completionHandler: rawptr) { - msgSend(nil, self, "newFunctionWithDescriptor:completionHandler:", descriptor, completionHandler) +Library_newFunctionWithDescriptorWithCompletionHandler :: #force_inline proc(self: ^Library, descriptor: ^FunctionDescriptor, completionHandler: rawptr) -> ^Function { + return msgSend(^Function, self, "newFunctionWithDescriptor:completionHandler:", descriptor, completionHandler) } @(objc_type=Library, objc_name="newFunctionWithDescriptor") -Library_newFunctionWithDescriptor :: #force_inline proc(self: ^Library, descriptor: ^FunctionDescriptor) -> (library: ^Library, error: ^NS.Error) { - library = msgSend(^Library, self, "newFunctionWithDescriptor:error:", descriptor, &error) +Library_newFunctionWithDescriptor :: #force_inline proc(self: ^Library, descriptor: ^FunctionDescriptor) -> (function: ^Function, error: ^NS.Error) { + function = msgSend(^Function, self, "newFunctionWithDescriptor:error:", descriptor, &error) return } @(objc_type=Library, objc_name="newFunctionWithName") -Library_newFunctionWithName :: #force_inline proc(self: ^Library, functionName: ^NS.String) -> ^Library { - return msgSend(^Library, self, "newFunctionWithName:", functionName) +Library_newFunctionWithName :: #force_inline proc(self: ^Library, functionName: ^NS.String) -> ^Function { + return msgSend(^Function, self, "newFunctionWithName:", functionName) } @(objc_type=Library, objc_name="newFunctionWithNameWithConstantValuesAndCompletionHandler") -Library_newFunctionWithNameWithConstantValuesAndCompletionHandler :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues, completionHandler: rawptr) { - msgSend(nil, self, "newFunctionWithName:constantValues:completionHandler:", name, constantValues, completionHandler) +Library_newFunctionWithNameWithConstantValuesAndCompletionHandler :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues, completionHandler: rawptr) -> ^Function { + return msgSend(^Function, self, "newFunctionWithName:constantValues:completionHandler:", name, constantValues, completionHandler) } @(objc_type=Library, objc_name="newFunctionWithNameWithConstantValues") -Library_newFunctionWithNameWithConstantValues :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues) -> (library: ^Library, error: ^NS.Error) { - library = msgSend(^Library, self, "newFunctionWithName:constantValues:error:", name, constantValues, &error) +Library_newFunctionWithNameWithConstantValues :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues) -> (function: ^Function, error: ^NS.Error) { + function = msgSend(^Function, self, "newFunctionWithName:constantValues:error:", name, constantValues, &error) return } @(objc_type=Library, objc_name="newIntersectionFunctionWithDescriptorWithCompletionHandler") -Library_newIntersectionFunctionWithDescriptorWithCompletionHandler :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor, completionHandler: rawptr) { - msgSend(nil, self, "newIntersectionFunctionWithDescriptor:completionHandler:", descriptor, completionHandler) +Library_newIntersectionFunctionWithDescriptorWithCompletionHandler :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor, completionHandler: rawptr) -> ^Function { + return msgSend(^Function, self, "newIntersectionFunctionWithDescriptor:completionHandler:", descriptor, completionHandler) } @(objc_type=Library, objc_name="newIntersectionFunctionWithDescriptor") -Library_newIntersectionFunctionWithDescriptor :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor) -> (library: ^Library, error: ^NS.Error) { - library = msgSend(^Library, self, "newIntersectionFunctionWithDescriptor:error:", descriptor, &error) +Library_newIntersectionFunctionWithDescriptor :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor) -> (function: ^Function, error: ^NS.Error) { + function = msgSend(^Function, self, "newIntersectionFunctionWithDescriptor:error:", descriptor, &error) return } @(objc_type=Library, objc_name="setLabel") From 7386ca9272c527800720c0dd53a9ad351345aa41 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 11:21:21 +0000 Subject: [PATCH 27/64] Add new objc intrinsics: objc_(register|find)_(selector|class) --- core/sys/darwin/Foundation/NSObject.odin | 2 +- src/check_builtin.cpp | 28 ++++- src/checker_builtin_procs.hpp | 11 +- src/llvm_backend.cpp | 5 +- src/llvm_backend_proc.cpp | 8 +- src/llvm_backend_utility.cpp | 133 +++++++++++++++++------ 6 files changed, 140 insertions(+), 47 deletions(-) diff --git a/core/sys/darwin/Foundation/NSObject.odin b/core/sys/darwin/Foundation/NSObject.odin index 82d837fb8..55d87a14b 100644 --- a/core/sys/darwin/Foundation/NSObject.odin +++ b/core/sys/darwin/Foundation/NSObject.odin @@ -70,7 +70,7 @@ description :: proc(self: ^Object) -> ^String { @(objc_type=Object, objc_name="debugDescription") debugDescription :: proc(self: ^Object) -> ^String { - if msgSendSafeCheck(self, intrinsics.objc_selector_name("debugDescription")) { + if msgSendSafeCheck(self, intrinsics.objc_find_selector("debugDescription")) { return msgSend(^String, self, "debugDescription") } return nil diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp index a9ee5d25f..a6b1759f5 100644 --- a/src/check_builtin.cpp +++ b/src/check_builtin.cpp @@ -348,13 +348,27 @@ bool check_builtin_objc_procedure(CheckerContext *c, Operand *operand, Ast *call return true; } break; - case BuiltinProc_objc_selector_name: { + case BuiltinProc_objc_find_selector: + case BuiltinProc_objc_find_class: + case BuiltinProc_objc_register_selector: + case BuiltinProc_objc_register_class: + { String sel_name = {}; if (!is_constant_string(c, builtin_name, ce->args[0], &sel_name)) { return false; } - operand->type = t_objc_SEL; + switch (id) { + case BuiltinProc_objc_find_selector: + case BuiltinProc_objc_register_selector: + operand->type = t_objc_SEL; + break; + case BuiltinProc_objc_find_class: + case BuiltinProc_objc_register_class: + operand->type = t_objc_Class; + break; + + } operand->mode = Addressing_Value; return true; } break; @@ -398,7 +412,10 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 case BuiltinProc_max: case BuiltinProc_type_is_subtype_of: case BuiltinProc_objc_send: - case BuiltinProc_objc_selector_name: + case BuiltinProc_objc_find_selector: + case BuiltinProc_objc_find_class: + case BuiltinProc_objc_register_selector: + case BuiltinProc_objc_register_class: // NOTE(bill): The first arg may be a Type, this will be checked case by case break; @@ -440,7 +457,10 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 break; case BuiltinProc_objc_send: - case BuiltinProc_objc_selector_name: + case BuiltinProc_objc_find_selector: + case BuiltinProc_objc_find_class: + case BuiltinProc_objc_register_selector: + case BuiltinProc_objc_register_class: return check_builtin_objc_procedure(c, operand, call, id, type_hint); case BuiltinProc___entry_point: diff --git a/src/checker_builtin_procs.hpp b/src/checker_builtin_procs.hpp index c14c18412..19fa94ee6 100644 --- a/src/checker_builtin_procs.hpp +++ b/src/checker_builtin_procs.hpp @@ -253,7 +253,10 @@ BuiltinProc__type_end, BuiltinProc___entry_point, BuiltinProc_objc_send, - BuiltinProc_objc_selector_name, + BuiltinProc_objc_find_selector, + BuiltinProc_objc_find_class, + BuiltinProc_objc_register_selector, + BuiltinProc_objc_register_class, BuiltinProc_COUNT, }; @@ -509,5 +512,9 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = { {STR_LIT("__entry_point"), 0, false, Expr_Stmt, BuiltinProcPkg_intrinsics}, {STR_LIT("objc_send"), 3, true, Expr_Expr, BuiltinProcPkg_intrinsics}, - {STR_LIT("objc_selector_name"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, + + {STR_LIT("objc_find_selector"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, + {STR_LIT("objc_find_class"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, + {STR_LIT("objc_register_selector"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, + {STR_LIT("objc_register_class"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, }; diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp index 7941c65a3..52c46cadc 100644 --- a/src/llvm_backend.cpp +++ b/src/llvm_backend.cpp @@ -672,12 +672,14 @@ void lb_finalize_objc_names(lbProcedure *p) { lb_populate_function_pass_manager(m, default_function_pass_manager, false, build_context.optimization_level); LLVMFinalizeFunctionPassManager(default_function_pass_manager); + + auto args = array_make(permanent_allocator(), 1); + LLVMSetLinkage(p->value, LLVMInternalLinkage); lb_begin_procedure_body(p); for_array(i, m->objc_classes.entries) { auto const &entry = m->objc_classes.entries[i]; String name = entry.key.string; - auto args = array_make(permanent_allocator(), 1); args[0] = lb_const_value(m, t_cstring, exact_value_string(name)); lbValue ptr = lb_emit_runtime_call(p, "objc_lookUpClass", args); lb_addr_store(p, entry.value, ptr); @@ -686,7 +688,6 @@ void lb_finalize_objc_names(lbProcedure *p) { for_array(i, m->objc_selectors.entries) { auto const &entry = m->objc_selectors.entries[i]; String name = entry.key.string; - auto args = array_make(permanent_allocator(), 1); args[0] = lb_const_value(m, t_cstring, exact_value_string(name)); lbValue ptr = lb_emit_runtime_call(p, "sel_registerName", args); lb_addr_store(p, entry.value, ptr); diff --git a/src/llvm_backend_proc.cpp b/src/llvm_backend_proc.cpp index caa3dfa1a..2a0380605 100644 --- a/src/llvm_backend_proc.cpp +++ b/src/llvm_backend_proc.cpp @@ -2108,10 +2108,12 @@ lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValue const &tv, } case BuiltinProc_objc_send: - return lb_handle_obj_send(p, expr); + return lb_handle_objc_send(p, expr); - case BuiltinProc_objc_selector_name: - return lb_handle_obj_selector_name(p, expr); + case BuiltinProc_objc_find_selector: return lb_handle_objc_find_selector(p, expr); + case BuiltinProc_objc_find_class: return lb_handle_objc_find_class(p, expr); + case BuiltinProc_objc_register_selector: return lb_handle_objc_register_selector(p, expr); + case BuiltinProc_objc_register_class: return lb_handle_objc_register_class(p, expr); } GB_PANIC("Unhandled built-in procedure %.*s", LIT(builtin_procs[id].name)); diff --git a/src/llvm_backend_utility.cpp b/src/llvm_backend_utility.cpp index 8ef66df7a..75fb89314 100644 --- a/src/llvm_backend_utility.cpp +++ b/src/llvm_backend_utility.cpp @@ -1823,7 +1823,101 @@ void lb_set_wasm_export_attributes(LLVMValueRef value, String export_name) { lbValue lb_lookup_runtime_procedure(lbModule *m, String const &name); -lbValue lb_handle_obj_id(lbProcedure *p, Ast *expr) { + +lbAddr lb_handle_objc_find_or_register_selector(lbProcedure *p, String const &name) { + lbAddr *found = string_map_get(&p->module->objc_selectors, name); + if (found) { + return *found; + } else { + lbModule *default_module = &p->module->gen->default_module; + Entity *e = nullptr; + lbAddr default_addr = lb_add_global_generated(default_module, t_objc_SEL, {}, &e); + + lbValue ptr = lb_find_value_from_entity(p->module, e); + lbAddr local_addr = lb_addr(ptr); + + string_map_set(&default_module->objc_selectors, name, default_addr); + if (default_module != p->module) { + string_map_set(&p->module->objc_selectors, name, local_addr); + } + return local_addr; + } +} + +lbValue lb_handle_objc_find_selector(lbProcedure *p, Ast *expr) { + ast_node(ce, CallExpr, expr); + + auto tav = ce->args[0]->tav; + GB_ASSERT(tav.value.kind == ExactValue_String); + String name = tav.value.value_string; + return lb_addr_load(p, lb_handle_objc_find_or_register_selector(p, name)); +} + +lbValue lb_handle_objc_register_selector(lbProcedure *p, Ast *expr) { + ast_node(ce, CallExpr, expr); + lbModule *m = p->module; + + auto tav = ce->args[0]->tav; + GB_ASSERT(tav.value.kind == ExactValue_String); + String name = tav.value.value_string; + lbAddr dst = lb_handle_objc_find_or_register_selector(p, name); + + auto args = array_make(permanent_allocator(), 1); + args[0] = lb_const_value(m, t_cstring, exact_value_string(name)); + lbValue ptr = lb_emit_runtime_call(p, "sel_registerName", args); + lb_addr_store(p, dst, ptr); + + return lb_addr_load(p, dst); +} + +lbAddr lb_handle_objc_find_or_register_class(lbProcedure *p, String const &name) { + lbAddr *found = string_map_get(&p->module->objc_classes, name); + if (found) { + return *found; + } else { + lbModule *default_module = &p->module->gen->default_module; + Entity *e = nullptr; + lbAddr default_addr = lb_add_global_generated(default_module, t_objc_SEL, {}, &e); + + lbValue ptr = lb_find_value_from_entity(p->module, e); + lbAddr local_addr = lb_addr(ptr); + + string_map_set(&default_module->objc_classes, name, default_addr); + if (default_module != p->module) { + string_map_set(&p->module->objc_classes, name, local_addr); + } + return local_addr; + } +} + +lbValue lb_handle_objc_find_class(lbProcedure *p, Ast *expr) { + ast_node(ce, CallExpr, expr); + + auto tav = ce->args[0]->tav; + GB_ASSERT(tav.value.kind == ExactValue_String); + String name = tav.value.value_string; + return lb_addr_load(p, lb_handle_objc_find_or_register_class(p, name)); +} + +lbValue lb_handle_objc_register_class(lbProcedure *p, Ast *expr) { + ast_node(ce, CallExpr, expr); + lbModule *m = p->module; + + auto tav = ce->args[0]->tav; + GB_ASSERT(tav.value.kind == ExactValue_String); + String name = tav.value.value_string; + lbAddr dst = lb_handle_objc_find_or_register_class(p, name); + + auto args = array_make(permanent_allocator(), 1); + args[0] = lb_const_value(m, t_cstring, exact_value_string(name)); + lbValue ptr = lb_emit_runtime_call(p, "objc_lookUpClass", args); + lb_addr_store(p, dst, ptr); + + return lb_addr_load(p, dst); +} + + +lbValue lb_handle_objc_id(lbProcedure *p, Ast *expr) { TypeAndValue const &tav = type_and_value_of_expr(expr); if (tav.mode == Addressing_Type) { Type *type = tav.type; @@ -1854,29 +1948,7 @@ lbValue lb_handle_obj_id(lbProcedure *p, Ast *expr) { return lb_build_expr(p, expr); } - -lbValue lb_handle_obj_selector(lbProcedure *p, String const &name) { - lbAddr *found = string_map_get(&p->module->objc_selectors, name); - if (found) { - return lb_addr_load(p, *found); - } else { - lbModule *default_module = &p->module->gen->default_module; - Entity *e = nullptr; - lbAddr default_addr = lb_add_global_generated(default_module, t_objc_SEL, {}, &e); - - lbValue ptr = lb_find_value_from_entity(p->module, e); - lbAddr local_addr = lb_addr(ptr); - - string_map_set(&default_module->objc_selectors, name, default_addr); - if (default_module != p->module) { - string_map_set(&p->module->objc_selectors, name, local_addr); - } - return lb_addr_load(p, local_addr); - } -} - - -lbValue lb_handle_obj_send(lbProcedure *p, Ast *expr) { +lbValue lb_handle_objc_send(lbProcedure *p, Ast *expr) { ast_node(ce, CallExpr, expr); lbModule *m = p->module; @@ -1887,10 +1959,10 @@ lbValue lb_handle_obj_send(lbProcedure *p, Ast *expr) { GB_ASSERT(ce->args.count >= 3); auto args = array_make(permanent_allocator(), 0, ce->args.count-1); - lbValue id = lb_handle_obj_id(p, ce->args[1]); + lbValue id = lb_handle_objc_id(p, ce->args[1]); Ast *sel_expr = ce->args[2]; GB_ASSERT(sel_expr->tav.value.kind == ExactValue_String); - lbValue sel = lb_handle_obj_selector(p, sel_expr->tav.value.value_string); + lbValue sel = lb_addr_load(p, lb_handle_objc_find_or_register_selector(p, sel_expr->tav.value.value_string)); array_add(&args, id); array_add(&args, sel); @@ -1917,12 +1989,3 @@ lbValue lb_handle_obj_send(lbProcedure *p, Ast *expr) { } -lbValue lb_handle_obj_selector_name(lbProcedure *p, Ast *expr) { - ast_node(ce, CallExpr, expr); - - auto tav = ce->args[0]->tav; - GB_ASSERT(tav.value.kind == ExactValue_String); - String name = tav.value.value_string; - return lb_handle_obj_selector(p, name); - -} \ No newline at end of file From ff7d591ebf7cf63f94c8e1f0f9c81c1475c90593 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 11:55:59 +0000 Subject: [PATCH 28/64] Correct AccelerationStructure classes --- core/sys/darwin/Metal/MetalClasses.odin | 264 ++++++++++++++++++++++-- core/sys/darwin/Metal/MetalEnums.odin | 11 + 2 files changed, 253 insertions(+), 22 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 6abf923ae..49f31bae9 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -33,8 +33,8 @@ AccelerationStructureBoundingBoxGeometryDescriptor_init :: #force_inline proc(se return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, self, "init") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxBuffer") -AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBuffer :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> ^AccelerationStructureBoundingBoxGeometryDescriptor { - return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, self, "boundingBoxBuffer") +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBuffer :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> ^Buffer { + return msgSend(^Buffer, self, "boundingBoxBuffer") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxBufferOffset") AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBufferOffset :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.UInteger { @@ -117,6 +117,138 @@ MotionKeyframeData_setOffset :: #force_inline proc(self: ^MotionKeyframeData, of msgSend(nil, self, "setOffset:", offset) } +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + AccelerationStructureMotionTriangleGeometryDescriptor +*/ + +@(objc_class="MTLAccelerationStructureMotionTriangleGeometryDescriptor") +AccelerationStructureMotionTriangleGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureMotionTriangleGeometryDescriptor), using _: AccelerationStructureGeometryDescriptor } + +@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_class_name="alloc") +AccelerationStructureMotionTriangleGeometryDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureMotionTriangleGeometryDescriptor { + return msgSend(^AccelerationStructureMotionTriangleGeometryDescriptor, AccelerationStructureMotionTriangleGeometryDescriptor, "alloc") +} +@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="init") +AccelerationStructureMotionTriangleGeometryDescriptor_init :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> ^AccelerationStructureMotionTriangleGeometryDescriptor { + return msgSend(^AccelerationStructureMotionTriangleGeometryDescriptor, self, "init") +} + +@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="vertexBuffers") +AccelerationStructureMotionTriangleGeometryDescriptor_vertexBuffers :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> ^NS.Array { + return msgSend(^NS.Array, self, "vertexBuffers") +} +@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="setVertexBuffers") +AccelerationStructureMotionTriangleGeometryDescriptor_setVertexBuffers :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor, buffers: ^NS.Array) { + msgSend(nil, self, "setVertexBuffers:", buffers) +} + +@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="vertexStride") +AccelerationStructureMotionTriangleGeometryDescriptor_vertexStride :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "vertexStride") +} +@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="setVertexStride") +AccelerationStructureMotionTriangleGeometryDescriptor_setVertexStride :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor, stride: NS.UInteger) { + msgSend(nil, self, "setVertexStride:", stride) +} + + +@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="indexBuffer") +AccelerationStructureMotionTriangleGeometryDescriptor_indexBuffer :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> ^Buffer { + return msgSend(^Buffer, self, "indexBuffer") +} +@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="setIndexBuffer") +AccelerationStructureMotionTriangleGeometryDescriptor_setIndexBuffer :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor, buffer: ^Buffer) { + msgSend(nil, self, "setIndexBuffer:", buffer) +} + + +@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="indexBufferOffset") +AccelerationStructureMotionTriangleGeometryDescriptor_indexBufferOffset :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "indexBufferOffset") +} +@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="setIndexBufferOffset") +AccelerationStructureMotionTriangleGeometryDescriptor_setIndexBufferOffset :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor, offset: NS.UInteger) { + msgSend(nil, self, "setIndexBufferOffset:", offset) +} + +@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="indexType") +AccelerationStructureMotionTriangleGeometryDescriptor_indexType :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> IndexType { + return msgSend(IndexType, self, "indexType") +} +@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="setIndexType") +AccelerationStructureMotionTriangleGeometryDescriptor_setIndexType :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor, indexType: IndexType) { + msgSend(nil, self, "setIndexType:", indexType) +} + +@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="triangleCount") +AccelerationStructureMotionTriangleGeometryDescriptor_triangleCount :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "triangleCount") +} +@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="setTriangleCount") +AccelerationStructureMotionTriangleGeometryDescriptor_setTriangleCount :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor, count: NS.UInteger) { + msgSend(nil, self, "setTriangleCount:", count) +} + +//////////////////////////////////////////////////////////////////////////////// + +/* +Class: + AccelerationStructureMotionBoundingBoxGeometryDescriptor +*/ + +@(objc_class="MTLAccelerationStructureMotionBoundingBoxGeometryDescriptor") +AccelerationStructureMotionBoundingBoxGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureMotionBoundingBoxGeometryDescriptor), using _: AccelerationStructureGeometryDescriptor } + +@(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_class_name="alloc") +AccelerationStructureMotionBoundingBoxGeometryDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureMotionBoundingBoxGeometryDescriptor { + return msgSend(^AccelerationStructureMotionBoundingBoxGeometryDescriptor, AccelerationStructureMotionBoundingBoxGeometryDescriptor, "alloc") +} +@(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_name="init") +AccelerationStructureMotionBoundingBoxGeometryDescriptor_init :: #force_inline proc(self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor) -> ^AccelerationStructureMotionBoundingBoxGeometryDescriptor { + return msgSend(^AccelerationStructureMotionBoundingBoxGeometryDescriptor, self, "init") +} + +@(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_class_name="descriptor") +AccelerationStructureMotionBoundingBoxGeometryDescriptor_descriptor :: #force_inline proc() -> ^AccelerationStructureMotionBoundingBoxGeometryDescriptor { + return msgSend(^AccelerationStructureMotionBoundingBoxGeometryDescriptor, AccelerationStructureMotionBoundingBoxGeometryDescriptor, "descriptor") +} + +@(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_name="boundingBoxBuffers") +AccelerationStructureMotionBoundingBoxGeometryDescriptor_boundingBoxBuffers :: #force_inline proc(self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor) -> ^NS.Array { + return msgSend(^NS.Array, self, "boundingBoxBuffers") +} +@(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_name="setBoundBoxBuffers") +AccelerationStructureMotionBoundingBoxGeometryDescriptor_setBoundBoxBuffers :: #force_inline proc(self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor, buffers: ^NS.Array) { + msgSend(nil, self, "setBoundBoxBuffers:", buffers) +} + +@(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_name="boundingBoxStride") +AccelerationStructureMotionBoundingBoxGeometryDescriptor_boundingBoxStride :: #force_inline proc(self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "boundingBoxStride") +} +@(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxStride") +AccelerationStructureMotionBoundingBoxGeometryDescriptor_setBoundingBoxStride :: #force_inline proc(self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor, stride: NS.UInteger) { + msgSend(nil, self, "setBoundingBoxStride:", stride) +} + +@(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_name="boundingBoxCount") +AccelerationStructureMotionBoundingBoxGeometryDescriptor_boundingBoxCount :: #force_inline proc(self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "boundingBoxCount") +} +@(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxCount") +AccelerationStructureMotionBoundingBoxGeometryDescriptor_setBoundingBoxCount :: #force_inline proc(self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor, offset: NS.UInteger) { + msgSend(nil, self, "setBoundingBoxCount:", offset) +} + + + + + + + //////////////////////////////////////////////////////////////////////////////// /* @@ -242,8 +374,8 @@ AccelerationStructureTriangleGeometryDescriptor_descriptor :: #force_inline proc return msgSend(^AccelerationStructureTriangleGeometryDescriptor, AccelerationStructureTriangleGeometryDescriptor, "descriptor") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="indexBuffer") -AccelerationStructureTriangleGeometryDescriptor_indexBuffer :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^AccelerationStructureTriangleGeometryDescriptor { - return msgSend(^AccelerationStructureTriangleGeometryDescriptor, self, "indexBuffer") +AccelerationStructureTriangleGeometryDescriptor_indexBuffer :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^Buffer { + return msgSend(^Buffer, self, "indexBuffer") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="indexBufferOffset") AccelerationStructureTriangleGeometryDescriptor_indexBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { @@ -286,8 +418,8 @@ AccelerationStructureTriangleGeometryDescriptor_triangleCount :: #force_inline p return msgSend(NS.UInteger, self, "triangleCount") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="vertexBuffer") -AccelerationStructureTriangleGeometryDescriptor_vertexBuffer :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^AccelerationStructureTriangleGeometryDescriptor { - return msgSend(^AccelerationStructureTriangleGeometryDescriptor, self, "vertexBuffer") +AccelerationStructureTriangleGeometryDescriptor_vertexBuffer :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^Buffer { + return msgSend(^Buffer, self, "vertexBuffer") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="vertexBufferOffset") AccelerationStructureTriangleGeometryDescriptor_vertexBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { @@ -781,8 +913,8 @@ BlitPassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_inlin return msgSend(NS.UInteger, self, "endOfEncoderSampleIndex") } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") -BlitPassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> ^BlitPassSampleBufferAttachmentDescriptor { - return msgSend(^BlitPassSampleBufferAttachmentDescriptor, self, "sampleBuffer") +BlitPassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> ^Buffer { + return msgSend(^Buffer, self, "sampleBuffer") } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex") BlitPassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.UInteger) { @@ -1260,8 +1392,8 @@ ComputePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_in return msgSend(NS.UInteger, self, "endOfEncoderSampleIndex") } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") -ComputePassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> ^ComputePassSampleBufferAttachmentDescriptor { - return msgSend(^ComputePassSampleBufferAttachmentDescriptor, self, "sampleBuffer") +ComputePassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> ^Buffer { + return msgSend(^Buffer, self, "sampleBuffer") } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex") ComputePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.UInteger) { @@ -1993,8 +2125,8 @@ InstanceAccelerationStructureDescriptor_instanceCount :: #force_inline proc(self return msgSend(NS.UInteger, self, "instanceCount") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceDescriptorBuffer") -InstanceAccelerationStructureDescriptor_instanceDescriptorBuffer :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> ^InstanceAccelerationStructureDescriptor { - return msgSend(^InstanceAccelerationStructureDescriptor, self, "instanceDescriptorBuffer") +InstanceAccelerationStructureDescriptor_instanceDescriptorBuffer :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> ^Buffer { + return msgSend(^Buffer, self, "instanceDescriptorBuffer") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceDescriptorBufferOffset") InstanceAccelerationStructureDescriptor_instanceDescriptorBufferOffset :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.UInteger { @@ -2029,6 +2161,46 @@ InstanceAccelerationStructureDescriptor_setInstancedAccelerationStructures :: #f msgSend(nil, self, "setInstancedAccelerationStructures:", instancedAccelerationStructures) } +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceDescriptorType") +InstanceAccelerationStructureDescriptor_instanceDescriptorType :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> AccelerationStructureInstanceDescriptorType { + return msgSend(AccelerationStructureInstanceDescriptorType, self, "instanceDescriptorType") +} +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceDescriptorType") +InstanceAccelerationStructureDescriptor_setInstanceDescriptorType :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, buffer: AccelerationStructureInstanceDescriptorType) { + msgSend(nil, self, "setInstanceDescriptorType:", buffer) +} + + +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="motionTransformBuffer") +InstanceAccelerationStructureDescriptor_motionTransformBuffer :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> ^Buffer { + return msgSend(^Buffer, self, "motionTransformBuffer") +} +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setMotionTransformBuffer") +InstanceAccelerationStructureDescriptor_setMotionTransformBuffer :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, buffer: ^Buffer) { + msgSend(nil, self, "setMotionTransformBuffer:", buffer) +} + + +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="motionTransformBufferOffset") +InstanceAccelerationStructureDescriptor_motionTransformBufferOffset :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "motionTransformBufferOffset") +} +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setMotionTransformBufferOffset") +InstanceAccelerationStructureDescriptor_setMotionTransformBufferOffset :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, offset: NS.UInteger) { + msgSend(nil, self, "setMotionTransformBufferOffset:", offset) +} + +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="motionTransformCount") +InstanceAccelerationStructureDescriptor_motionTransformCount :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "motionTransformCount") +} +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setMotionTransformCount") +InstanceAccelerationStructureDescriptor_setMotionTransformCount :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, offset: NS.UInteger) { + msgSend(nil, self, "setMotionTransformCount:", offset) +} + + + //////////////////////////////////////////////////////////////////////////////// /* @@ -2281,6 +2453,54 @@ PrimitiveAccelerationStructureDescriptor_setGeometryDescriptors :: #force_inline msgSend(nil, self, "setGeometryDescriptors:", geometryDescriptors) } +@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="motionStartBorderMode") +PrimitiveAccelerationStructureDescriptor_motionStartBorderMode :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor) -> MotionBorderMode { + return msgSend(MotionBorderMode, self, "motionStartBorderMode") +} +@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="setMotionStartBorderMode") +PrimitiveAccelerationStructureDescriptor_setMotionStartBorderMode :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor, motionStartBorderMode: MotionBorderMode) { + msgSend(nil, self, "setMotionStartBorderMode:", motionStartBorderMode) +} + +@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="motionEndBorderMode") +PrimitiveAccelerationStructureDescriptor_motionEndBorderMode :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor) -> MotionBorderMode { + return msgSend(MotionBorderMode, self, "motionEndBorderMode") +} +@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="setMotionEndBorderMode") +PrimitiveAccelerationStructureDescriptor_setMotionEndBorderMode :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor, motionEndBorderMode: MotionBorderMode) { + msgSend(nil, self, "setMotionEndBorderMode:", motionEndBorderMode) +} + +@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="motionStartTime") +PrimitiveAccelerationStructureDescriptor_motionStartTime :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor) -> f32 { + return msgSend(f32, self, "motionStartTime") +} +@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="setMotionStartTime") +PrimitiveAccelerationStructureDescriptor_setMotionStartTime :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor, motionStartTime: f32) { + msgSend(nil, self, "setMotionStartTime:", motionStartTime) +} + + +@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="motionEndTime") +PrimitiveAccelerationStructureDescriptor_motionEndTime :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor) -> f32 { + return msgSend(f32, self, "motionEndTime") +} +@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="setMotionEndTime") +PrimitiveAccelerationStructureDescriptor_setMotionEndTime :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor, motionEndTime: f32) { + msgSend(nil, self, "setMotionEndTime:", motionEndTime) +} + +@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="motionKeyframeCount") +PrimitiveAccelerationStructureDescriptor_motionKeyframeCount :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor) -> NS.UInteger { + return msgSend(NS.UInteger, self, "motionKeyframeCount") +} +@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="setMotionKeyframeCount") +PrimitiveAccelerationStructureDescriptor_setMotionKeyframeCount :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor, motionKeyframeCount: NS.UInteger) { + msgSend(nil, self, "setMotionKeyframeCount:", motionKeyframeCount) +} + + + //////////////////////////////////////////////////////////////////////////////// /* @@ -2880,8 +3100,8 @@ RenderPassDescriptor_tileWidth :: #force_inline proc(self: ^RenderPassDescriptor return msgSend(NS.UInteger, self, "tileWidth") } @(objc_type=RenderPassDescriptor, objc_name="visibilityResultBuffer") -RenderPassDescriptor_visibilityResultBuffer :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RenderPassDescriptor { - return msgSend(^RenderPassDescriptor, self, "visibilityResultBuffer") +RenderPassDescriptor_visibilityResultBuffer :: #force_inline proc(self: ^RenderPassDescriptor) -> ^Buffer { + return msgSend(^Buffer, self, "visibilityResultBuffer") } //////////////////////////////////////////////////////////////////////////////// @@ -2924,8 +3144,8 @@ RenderPassSampleBufferAttachmentDescriptor_endOfVertexSampleIndex :: #force_inli return msgSend(NS.UInteger, self, "endOfVertexSampleIndex") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") -RenderPassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> ^RenderPassSampleBufferAttachmentDescriptor { - return msgSend(^RenderPassSampleBufferAttachmentDescriptor, self, "sampleBuffer") +RenderPassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> ^Buffer { + return msgSend(^Buffer, self, "sampleBuffer") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setEndOfFragmentSampleIndex") RenderPassSampleBufferAttachmentDescriptor_setEndOfFragmentSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, endOfFragmentSampleIndex: NS.UInteger) { @@ -3537,8 +3757,8 @@ ResourceStatePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #fo return msgSend(NS.UInteger, self, "endOfEncoderSampleIndex") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") -ResourceStatePassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> ^ResourceStatePassSampleBufferAttachmentDescriptor { - return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, self, "sampleBuffer") +ResourceStatePassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> ^Buffer { + return msgSend(^Buffer, self, "sampleBuffer") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex") ResourceStatePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.UInteger) { @@ -4985,11 +5205,11 @@ ArgumentEncoder_setComputePipelineStates :: #force_inline proc(self: ^ArgumentEn msgSend(nil, self, "setComputePipelineStates:withRange:", pipelines, range) } @(objc_type=ArgumentEncoder, objc_name="setIndirectCommandBuffer") -ArgumentEncoder_setIndirectCommandBuffer :: #force_inline proc(self: ^ArgumentEncoder, indirectCommandBuffer: ^Buffer, index: NS.UInteger) { +ArgumentEncoder_setIndirectCommandBuffer :: #force_inline proc(self: ^ArgumentEncoder, indirectCommandBuffer: ^IndirectCommandBuffer, index: NS.UInteger) { msgSend(nil, self, "setIndirectCommandBuffer:atIndex:", indirectCommandBuffer, index) } @(objc_type=ArgumentEncoder, objc_name="setIndirectCommandBuffers") -ArgumentEncoder_setIndirectCommandBuffers :: #force_inline proc(self: ^ArgumentEncoder, buffers: [^]^Buffer, range: NS.Range) { +ArgumentEncoder_setIndirectCommandBuffers :: #force_inline proc(self: ^ArgumentEncoder, buffers: [^]^IndirectCommandBuffer, range: NS.Range) { msgSend(nil, self, "setIndirectCommandBuffers:withRange:", buffers, range) } @(objc_type=ArgumentEncoder, objc_name="setIntersectionFunctionTable") @@ -7980,8 +8200,8 @@ Texture_arrayLength :: #force_inline proc(self: ^Texture) -> NS.UInteger { return msgSend(NS.UInteger, self, "arrayLength") } @(objc_type=Texture, objc_name="buffer") -Texture_buffer :: #force_inline proc(self: ^Texture) -> ^Texture { - return msgSend(^Texture, self, "buffer") +Texture_buffer :: #force_inline proc(self: ^Texture) -> ^Buffer { + return msgSend(^Buffer, self, "buffer") } @(objc_type=Texture, objc_name="bufferBytesPerRow") Texture_bufferBytesPerRow :: #force_inline proc(self: ^Texture) -> NS.UInteger { diff --git a/core/sys/darwin/Metal/MetalEnums.odin b/core/sys/darwin/Metal/MetalEnums.odin index 0e3aec321..47059ee66 100644 --- a/core/sys/darwin/Metal/MetalEnums.odin +++ b/core/sys/darwin/Metal/MetalEnums.odin @@ -17,6 +17,17 @@ AccelerationStructureInstanceOption :: enum u32 { NonOpaque = 3, } +MotionBorderMode :: enum u32 { + Clamp = 0, + Vanish = 1, +} + +AccelerationStructureInstanceDescriptorType :: enum NS.UInteger { + Default = 0, + UserID = 1, + Motion = 2, +}; + DataType :: enum NS.UInteger { None = 0, From debe2de5fe549775c9c40a307a5009c9ee388c88 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 12:12:23 +0000 Subject: [PATCH 29/64] Correct Acceleration Structure Types --- core/sys/darwin/Metal/MetalClasses.odin | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 49f31bae9..682b1dd20 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -5071,11 +5071,11 @@ AccelerationStructureCommandEncoder_buildAccelerationStructure :: #force_inline msgSend(nil, self, "buildAccelerationStructure:descriptor:scratchBuffer:scratchBufferOffset:", accelerationStructure, descriptor, scratchBuffer, scratchBufferOffset) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="copyAccelerationStructure") -AccelerationStructureCommandEncoder_copyAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^AccelerationStructure, destinationAccelerationStructure: ^AccelerationStructure) { +AccelerationStructureCommandEncoder_copyAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure, destinationAccelerationStructure: ^AccelerationStructure) { msgSend(nil, self, "copyAccelerationStructure:toAccelerationStructure:", sourceAccelerationStructure, destinationAccelerationStructure) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="copyAndCompactAccelerationStructure") -AccelerationStructureCommandEncoder_copyAndCompactAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^AccelerationStructure, destinationAccelerationStructure: ^AccelerationStructure) { +AccelerationStructureCommandEncoder_copyAndCompactAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure, destinationAccelerationStructure: ^AccelerationStructure) { msgSend(nil, self, "copyAndCompactAccelerationStructure:toAccelerationStructure:", sourceAccelerationStructure, destinationAccelerationStructure) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="refitAccelerationStructure") @@ -5095,16 +5095,16 @@ AccelerationStructureCommandEncoder_useHeap :: #force_inline proc(self: ^Acceler msgSend(nil, self, "useHeap:", heap) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="useHeaps") -AccelerationStructureCommandEncoder_useHeaps :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, heaps: [^]^Heap, count: NS.UInteger) { - msgSend(nil, self, "useHeaps:count:", heaps, count) +AccelerationStructureCommandEncoder_useHeaps :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, heaps: []^Heap) { + msgSend(nil, self, "useHeaps:count:", raw_data(heaps), NS.UInteger(len(heaps))) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="useResource") AccelerationStructureCommandEncoder_useResource :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, resource: ^Resource, usage: ResourceUsage) { msgSend(nil, self, "useResource:usage:", resource, usage) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="useResources") -AccelerationStructureCommandEncoder_useResources :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, resources: [^]^Resource, count: NS.UInteger, usage: ResourceUsage) { - msgSend(nil, self, "useResources:count:usage:", resources, count, usage) +AccelerationStructureCommandEncoder_useResources :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, resources: []^Resource, usage: ResourceUsage) { + msgSend(nil, self, "useResources:count:usage:", resources, NS.UInteger(len(resources)), usage) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="waitForFence") AccelerationStructureCommandEncoder_waitForFence :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, fence: ^Fence) { From 83a61694635b047ecfaa294a74e3338920f9111c Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 12:32:45 +0000 Subject: [PATCH 30/64] Update ArgumentEncoder --- core/sys/darwin/Metal/MetalClasses.odin | 51 ++++++++++++++++--------- 1 file changed, 33 insertions(+), 18 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 682b1dd20..d60a743a6 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -5161,8 +5161,8 @@ ArgumentEncoder_constantDataAtIndex :: #force_inline proc(self: ^ArgumentEncoder return msgSend(rawptr, self, "constantDataAtIndex:", index) } @(objc_type=ArgumentEncoder, objc_name="device") -ArgumentEncoder_device :: #force_inline proc(self: ^ArgumentEncoder) -> ^ArgumentEncoder { - return msgSend(^ArgumentEncoder, self, "device") +ArgumentEncoder_device :: #force_inline proc(self: ^ArgumentEncoder) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=ArgumentEncoder, objc_name="encodedLength") ArgumentEncoder_encodedLength :: #force_inline proc(self: ^ArgumentEncoder) -> NS.UInteger { @@ -5193,32 +5193,39 @@ ArgumentEncoder_setBuffer :: #force_inline proc(self: ^ArgumentEncoder, buffer: msgSend(nil, self, "setBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=ArgumentEncoder, objc_name="setBuffers") -ArgumentEncoder_setBuffers :: #force_inline proc(self: ^ArgumentEncoder, buffers: [^]^Buffer, offsets: [^]NS.UInteger, range: NS.Range) { - msgSend(nil, self, "setBuffers:offsets:withRange:", buffers, offsets, range) +ArgumentEncoder_setBuffers :: #force_inline proc(self: ^ArgumentEncoder, buffers: []^Buffer, offsets: []NS.UInteger, range: NS.Range) { + assert(len(buffers) == len(offsets)) + msgSend(nil, self, "setBuffers:offsets:withRange:", raw_data(buffers), raw_data(offsets), range) } @(objc_type=ArgumentEncoder, objc_name="setComputePipelineState") ArgumentEncoder_setComputePipelineState :: #force_inline proc(self: ^ArgumentEncoder, pipeline: ^ComputePipelineState, index: NS.UInteger) { msgSend(nil, self, "setComputePipelineState:atIndex:", pipeline, index) } @(objc_type=ArgumentEncoder, objc_name="setComputePipelineStates") -ArgumentEncoder_setComputePipelineStates :: #force_inline proc(self: ^ArgumentEncoder, pipelines: [^]^ComputePipelineState, range: NS.Range) { - msgSend(nil, self, "setComputePipelineStates:withRange:", pipelines, range) +ArgumentEncoder_setComputePipelineStates :: #force_inline proc(self: ^ArgumentEncoder, pipelines: []^ComputePipelineState, range: NS.Range) { + assert(range.location < NS.UInteger(len(pipelines))) + assert(range.length <= NS.UInteger(len(pipelines))) + msgSend(nil, self, "setComputePipelineStates:withRange:", raw_data(pipelines), range) } @(objc_type=ArgumentEncoder, objc_name="setIndirectCommandBuffer") ArgumentEncoder_setIndirectCommandBuffer :: #force_inline proc(self: ^ArgumentEncoder, indirectCommandBuffer: ^IndirectCommandBuffer, index: NS.UInteger) { msgSend(nil, self, "setIndirectCommandBuffer:atIndex:", indirectCommandBuffer, index) } @(objc_type=ArgumentEncoder, objc_name="setIndirectCommandBuffers") -ArgumentEncoder_setIndirectCommandBuffers :: #force_inline proc(self: ^ArgumentEncoder, buffers: [^]^IndirectCommandBuffer, range: NS.Range) { - msgSend(nil, self, "setIndirectCommandBuffers:withRange:", buffers, range) +ArgumentEncoder_setIndirectCommandBuffers :: #force_inline proc(self: ^ArgumentEncoder, buffers: []^IndirectCommandBuffer, range: NS.Range) { + assert(range.location < NS.UInteger(len(buffers))) + assert(range.length <= NS.UInteger(len(buffers))) + msgSend(nil, self, "setIndirectCommandBuffers:withRange:", raw_data(buffers), range) } @(objc_type=ArgumentEncoder, objc_name="setIntersectionFunctionTable") ArgumentEncoder_setIntersectionFunctionTable :: #force_inline proc(self: ^ArgumentEncoder, intersectionFunctionTable: ^IntersectionFunctionTable, index: NS.UInteger) { msgSend(nil, self, "setIntersectionFunctionTable:atIndex:", intersectionFunctionTable, index) } @(objc_type=ArgumentEncoder, objc_name="setIntersectionFunctionTables") -ArgumentEncoder_setIntersectionFunctionTables :: #force_inline proc(self: ^ArgumentEncoder, intersectionFunctionTables: [^]^IntersectionFunctionTable, range: NS.Range) { - msgSend(nil, self, "setIntersectionFunctionTables:withRange:", intersectionFunctionTables, range) +ArgumentEncoder_setIntersectionFunctionTables :: #force_inline proc(self: ^ArgumentEncoder, intersectionFunctionTables: []^IntersectionFunctionTable, range: NS.Range) { + assert(range.location < NS.UInteger(len(intersectionFunctionTables))) + assert(range.length <= NS.UInteger(len(intersectionFunctionTables))) + msgSend(nil, self, "setIntersectionFunctionTables:withRange:", raw_data(intersectionFunctionTables), range) } @(objc_type=ArgumentEncoder, objc_name="setLabel") ArgumentEncoder_setLabel :: #force_inline proc(self: ^ArgumentEncoder, label: ^NS.String) { @@ -5229,32 +5236,40 @@ ArgumentEncoder_setRenderPipelineState :: #force_inline proc(self: ^ArgumentEnco msgSend(nil, self, "setRenderPipelineState:atIndex:", pipeline, index) } @(objc_type=ArgumentEncoder, objc_name="setRenderPipelineStates") -ArgumentEncoder_setRenderPipelineStates :: #force_inline proc(self: ^ArgumentEncoder, pipelines: [^]^RenderPipelineState, range: NS.Range) { - msgSend(nil, self, "setRenderPipelineStates:withRange:", pipelines, range) +ArgumentEncoder_setRenderPipelineStates :: #force_inline proc(self: ^ArgumentEncoder, pipelines: []^RenderPipelineState, range: NS.Range) { + assert(range.location < NS.UInteger(len(pipelines))) + assert(range.length <= NS.UInteger(len(pipelines))) + msgSend(nil, self, "setRenderPipelineStates:withRange:", raw_data(pipelines), range) } @(objc_type=ArgumentEncoder, objc_name="setSamplerState") ArgumentEncoder_setSamplerState :: #force_inline proc(self: ^ArgumentEncoder, sampler: ^SamplerState, index: NS.UInteger) { msgSend(nil, self, "setSamplerState:atIndex:", sampler, index) } @(objc_type=ArgumentEncoder, objc_name="setSamplerStates") -ArgumentEncoder_setSamplerStates :: #force_inline proc(self: ^ArgumentEncoder, samplers: [^]^SamplerState, range: NS.Range) { - msgSend(nil, self, "setSamplerStates:withRange:", samplers, range) +ArgumentEncoder_setSamplerStates :: #force_inline proc(self: ^ArgumentEncoder, samplers: []^SamplerState, range: NS.Range) { + assert(range.location < NS.UInteger(len(samplers))) + assert(range.length <= NS.UInteger(len(samplers))) + msgSend(nil, self, "setSamplerStates:withRange:", raw_data(samplers), range) } @(objc_type=ArgumentEncoder, objc_name="setTexture") ArgumentEncoder_setTexture :: #force_inline proc(self: ^ArgumentEncoder, texture: ^Texture, index: NS.UInteger) { msgSend(nil, self, "setTexture:atIndex:", texture, index) } @(objc_type=ArgumentEncoder, objc_name="setTextures") -ArgumentEncoder_setTextures :: #force_inline proc(self: ^ArgumentEncoder, textures: [^]^Texture, range: NS.Range) { - msgSend(nil, self, "setTextures:withRange:", textures, range) +ArgumentEncoder_setTextures :: #force_inline proc(self: ^ArgumentEncoder, textures: []^Texture, range: NS.Range) { + assert(range.location < NS.UInteger(len(textures))) + assert(range.length <= NS.UInteger(len(textures))) + msgSend(nil, self, "setTextures:withRange:", raw_data(textures), range) } @(objc_type=ArgumentEncoder, objc_name="setVisibleFunctionTable") ArgumentEncoder_setVisibleFunctionTable :: #force_inline proc(self: ^ArgumentEncoder, visibleFunctionTable: ^VisibleFunctionTable, index: NS.UInteger) { msgSend(nil, self, "setVisibleFunctionTable:atIndex:", visibleFunctionTable, index) } @(objc_type=ArgumentEncoder, objc_name="setVisibleFunctionTables") -ArgumentEncoder_setVisibleFunctionTables :: #force_inline proc(self: ^ArgumentEncoder, visibleFunctionTables: [^]^VisibleFunctionTable, range: NS.Range) { - msgSend(nil, self, "setVisibleFunctionTables:withRange:", visibleFunctionTables, range) +ArgumentEncoder_setVisibleFunctionTables :: #force_inline proc(self: ^ArgumentEncoder, visibleFunctionTables: []^VisibleFunctionTable, range: NS.Range) { + assert(range.location < NS.UInteger(len(visibleFunctionTables))) + assert(range.length <= NS.UInteger(len(visibleFunctionTables))) + msgSend(nil, self, "setVisibleFunctionTables:withRange:", raw_data(visibleFunctionTables), range) } //////////////////////////////////////////////////////////////////////////////// From 9a43c0672ef941465736f44a773dec2ef7f11718 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 12:36:28 +0000 Subject: [PATCH 31/64] Correct BinaryArchive --- core/sys/darwin/Metal/MetalClasses.odin | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index d60a743a6..fefeaeb47 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -1163,7 +1163,7 @@ CaptureManager_startCaptureWithCommandQueue :: #force_inline proc(self: ^Capture msgSend(nil, self, "startCaptureWithCommandQueue:", commandQueue) } @(objc_type=CaptureManager, objc_name="startCaptureWithDescriptor") -CaptureManager_startCaptureWithDescriptor :: #force_inline proc(self: ^CaptureManager, descriptor: ^CaptureDescriptor) -> (ok: bool, error: ^NS.Error) { +CaptureManager_startCaptureWithDescriptor :: #force_inline proc(self: ^CaptureManager, descriptor: ^CaptureDescriptor) -> (ok: BOOL, error: ^NS.Error) { ok = msgSend(BOOL, self, "startCaptureWithDescriptor:error:", descriptor, &error) return } @@ -5291,30 +5291,30 @@ Methods: BinaryArchive :: struct { using _: NS.Copying(BinaryArchive) } @(objc_type=BinaryArchive, objc_name="addComputePipelineFunctionsWithDescriptor") -BinaryArchive_addComputePipelineFunctionsWithDescriptor :: #force_inline proc(self: ^BinaryArchive, descriptor: ^ComputePipelineDescriptor) -> (ok: bool, error: ^NS.Error) { +BinaryArchive_addComputePipelineFunctionsWithDescriptor :: #force_inline proc(self: ^BinaryArchive, descriptor: ^ComputePipelineDescriptor) -> (ok: BOOL, error: ^NS.Error) { ok = msgSend(BOOL, self, "addComputePipelineFunctionsWithDescriptor:error:", descriptor, &error) return } @(objc_type=BinaryArchive, objc_name="addRenderPipelineFunctionsWithDescriptor") -BinaryArchive_addRenderPipelineFunctionsWithDescriptor :: #force_inline proc(self: ^BinaryArchive, descriptor: ^RenderPipelineDescriptor) -> (ok: bool, error: ^NS.Error) { +BinaryArchive_addRenderPipelineFunctionsWithDescriptor :: #force_inline proc(self: ^BinaryArchive, descriptor: ^RenderPipelineDescriptor) -> (ok: BOOL, error: ^NS.Error) { ok = msgSend(BOOL, self, "addRenderPipelineFunctionsWithDescriptor:error:", descriptor, &error) return } @(objc_type=BinaryArchive, objc_name="addTileRenderPipelineFunctionsWithDescriptor") -BinaryArchive_addTileRenderPipelineFunctionsWithDescriptor :: #force_inline proc(self: ^BinaryArchive, descriptor: ^TileRenderPipelineDescriptor) -> (ok: bool, error: ^NS.Error) { +BinaryArchive_addTileRenderPipelineFunctionsWithDescriptor :: #force_inline proc(self: ^BinaryArchive, descriptor: ^TileRenderPipelineDescriptor) -> (ok: BOOL, error: ^NS.Error) { ok = msgSend(BOOL, self, "addTileRenderPipelineFunctionsWithDescriptor:error:", descriptor, &error) return } @(objc_type=BinaryArchive, objc_name="device") -BinaryArchive_device :: #force_inline proc(self: ^BinaryArchive) -> ^BinaryArchive { - return msgSend(^BinaryArchive, self, "device") +BinaryArchive_device :: #force_inline proc(self: ^BinaryArchive) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=BinaryArchive, objc_name="label") BinaryArchive_label :: #force_inline proc(self: ^BinaryArchive) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=BinaryArchive, objc_name="serializeToURL") -BinaryArchive_serializeToURL :: #force_inline proc(self: ^BinaryArchive, url: ^NS.URL) -> (ok: bool, error: ^NS.Error) { +BinaryArchive_serializeToURL :: #force_inline proc(self: ^BinaryArchive, url: ^NS.URL) -> (ok: BOOL, error: ^NS.Error) { ok = msgSend(BOOL, self, "serializeToURL:error:", url, &error) return } @@ -5323,6 +5323,13 @@ BinaryArchive_setLabel :: #force_inline proc(self: ^BinaryArchive, label: ^NS.St msgSend(nil, self, "setLabel:", label) } + +@(objc_type=BinaryArchive, objc_name="addFunction") +BinaryArchive_addFunction :: #force_inline proc(self: ^BinaryArchive, descriptor: ^FunctionDescriptor, library: ^Library) -> (ok: BOOL, error: ^NS.Error) { + ok = msgSend(BOOL, self, "addFunction:", descriptor, library, &error) + return +} + //////////////////////////////////////////////////////////////////////////////// /* @@ -6788,7 +6795,7 @@ DynamicLibrary_label :: #force_inline proc(self: ^DynamicLibrary) -> ^NS.String return msgSend(^NS.String, self, "label") } @(objc_type=DynamicLibrary, objc_name="serializeToURL") -DynamicLibrary_serializeToURL :: #force_inline proc(self: ^DynamicLibrary, url: ^NS.URL) -> (ok: bool, error: ^NS.Error) { +DynamicLibrary_serializeToURL :: #force_inline proc(self: ^DynamicLibrary, url: ^NS.URL) -> (ok: BOOL, error: ^NS.Error) { ok = msgSend(BOOL, self, "serializeToURL:error:", url, &error) return } From 09e9dca86951dbedac057105437fdf3ca60f3b52 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 12:43:01 +0000 Subject: [PATCH 32/64] Improve BlitCommandEncoder --- core/sys/darwin/Metal/MetalClasses.odin | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index fefeaeb47..ad59ccaee 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -5366,32 +5366,32 @@ Methods: @(objc_class="MTLBlitCommandEncoder") BlitCommandEncoder :: struct { using _: CommandEncoder } -@(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_") +@(objc_type=BlitCommandEncoder, objc_name="copyFromBufferEx") BlitCommandEncoder_copyFromBufferEx :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^Buffer, sourceOffset: NS.UInteger, sourceBytesPerRow: NS.UInteger, sourceBytesPerImage: NS.UInteger, sourceSize: Size, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, destinationOrigin: Origin) { msgSend(nil, self, "copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:", sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin) } -@(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_") +@(objc_type=BlitCommandEncoder, objc_name="copyFromBufferExWithOptions") BlitCommandEncoder_copyFromBufferExWithOptions :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^Buffer, sourceOffset: NS.UInteger, sourceBytesPerRow: NS.UInteger, sourceBytesPerImage: NS.UInteger, sourceSize: Size, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, destinationOrigin: Origin, options: BlitOption) { msgSend(nil, self, "copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:options:", sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin, options) } -@(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_") -BlitCommandEncoder_copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^Buffer, sourceOffset: NS.UInteger, destinationBuffer: ^Buffer, destinationOffset: NS.UInteger, size: NS.UInteger) { +@(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer") +BlitCommandEncoder_copyFromBuffer :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^Buffer, sourceOffset: NS.UInteger, destinationBuffer: ^Buffer, destinationOffset: NS.UInteger, size: NS.UInteger) { msgSend(nil, self, "copyFromBuffer:sourceOffset:toBuffer:destinationOffset:size:", sourceBuffer, sourceOffset, destinationBuffer, destinationOffset, size) } -@(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_") -BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^Buffer, destinationOffset: NS.UInteger, destinationBytesPerRow: NS.UInteger, destinationBytesPerImage: NS.UInteger) { +@(objc_type=BlitCommandEncoder, objc_name="copyFromTextureEx") +BlitCommandEncoder_copyFromTextureEx :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^Buffer, destinationOffset: NS.UInteger, destinationBytesPerRow: NS.UInteger, destinationBytesPerImage: NS.UInteger) { msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:", sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage) } -@(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_") -BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^Buffer, destinationOffset: NS.UInteger, destinationBytesPerRow: NS.UInteger, destinationBytesPerImage: NS.UInteger, options: BlitOption) { +@(objc_type=BlitCommandEncoder, objc_name="copyFromTextureExWithOptions") +BlitCommandEncoder_copyFromTextureExWithOptions :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^Buffer, destinationOffset: NS.UInteger, destinationBytesPerRow: NS.UInteger, destinationBytesPerImage: NS.UInteger, options: BlitOption) { msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:options:", sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage, options) } -@(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_") -BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, sourceOrigin: Origin, sourceSize: Size, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, destinationOrigin: Origin) { +@(objc_type=BlitCommandEncoder, objc_name="copyFromTextureWithDestinationOrigin") +BlitCommandEncoder_copyFromTextureWithDestinationOrigin :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, sourceOrigin: Origin, sourceSize: Size, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, destinationOrigin: Origin) { msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:", sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin) } -@(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_") -BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_ :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, sliceCount: NS.UInteger, levelCount: NS.UInteger) { +@(objc_type=BlitCommandEncoder, objc_name="copyFromTextureWithCounts") +BlitCommandEncoder_copyFromTextureWithCounts :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, sliceCount: NS.UInteger, levelCount: NS.UInteger) { msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:toTexture:destinationSlice:destinationLevel:sliceCount:levelCount:", sourceTexture, sourceSlice, sourceLevel, destinationTexture, destinationSlice, destinationLevel, sliceCount, levelCount) } @(objc_type=BlitCommandEncoder, objc_name="copyFromTexture") From 02646b789c7d999139cbbbfd8b0f7e392d51341a Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 12:44:57 +0000 Subject: [PATCH 33/64] Correct typo --- core/sys/darwin/Metal/MetalClasses.odin | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index ad59ccaee..a2d483317 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -6599,9 +6599,9 @@ Device_newRenderPipelineStateWithTileDescriptorWithReflection :: #force_inline p pipeline = msgSend(^RenderPipelineState, self, "newRenderPipelineStateWithTileDescriptor:options:reflection:error:", descriptor, options, reflection, &error) return } -@(objc_type=Device, objc_name="newSamplerState") +@(objc_type=Device, objc_name="newSamplerStateWithDescriptor") Device_newSamplerState :: #force_inline proc(self: ^Device, descriptor: ^SamplerDescriptor) -> ^SamplerState { - return msgSend(^SamplerState, self, "newSamplerState:", descriptor) + return msgSend(^SamplerState, self, "newSamplerStateWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newSharedEvent") Device_newSharedEvent :: #force_inline proc(self: ^Device) -> ^SharedEvent { From 5936fa88717f82869e5378beb440891b72a693a5 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 12:46:46 +0000 Subject: [PATCH 34/64] Correct Blit Pass --- core/sys/darwin/Metal/MetalClasses.odin | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index a2d483317..26f603564 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -913,15 +913,15 @@ BlitPassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_inlin return msgSend(NS.UInteger, self, "endOfEncoderSampleIndex") } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") -BlitPassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> ^Buffer { - return msgSend(^Buffer, self, "sampleBuffer") +BlitPassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> ^CounterSampleBuffer { + return msgSend(^CounterSampleBuffer, self, "sampleBuffer") } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex") BlitPassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.UInteger) { msgSend(nil, self, "setEndOfEncoderSampleIndex:", endOfEncoderSampleIndex) } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") -BlitPassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor, sampleBuffer: ^Buffer) { +BlitPassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor, sampleBuffer: ^CounterSampleBuffer) { msgSend(nil, self, "setSampleBuffer:", sampleBuffer) } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="setStartOfEncoderSampleIndex") From 95e9bbf99f3110194edb20f166e896f8cadc68d7 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 12:52:30 +0000 Subject: [PATCH 35/64] Improve Buffer --- core/sys/darwin/Metal/MetalClasses.odin | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 26f603564..c025778ea 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -5491,8 +5491,14 @@ Buffer_addDebugMarker :: #force_inline proc(self: ^Buffer, marker: ^NS.String, r msgSend(nil, self, "addDebugMarker:range:", marker, range) } @(objc_type=Buffer, objc_name="contents") -Buffer_contents :: #force_inline proc(self: ^Buffer) -> rawptr { - return msgSend(rawptr, self, "contents") +Buffer_contents :: #force_inline proc(self: ^Buffer) -> []byte { + contents := msgSend([^]byte, self, "contents") + length := Buffer_length(self) + return contents[:length] +} +@(objc_type=Buffer, objc_name="contentsPointer") +Buffer_contentsPointer :: #force_inline proc(self: ^Buffer) -> rawptr { + return msgSend([^]byte, self, "contents") } @(objc_type=Buffer, objc_name="didModifyRange") Buffer_didModifyRange :: #force_inline proc(self: ^Buffer, range: NS.Range) { @@ -5519,6 +5525,11 @@ Buffer_removeAllDebugMarkers :: #force_inline proc(self: ^Buffer) { msgSend(nil, self, "removeAllDebugMarkers") } +@(objc_type=Buffer, objc_name="newTexture") +Buffer_newTexture :: #force_inline proc(self: ^Buffer, descriptor: ^TextureDescriptor, offset: NS.UInteger, bytesPerRow: NS.UInteger) -> ^Texture { + return msgSend(^Texture, self, "newTextureWithDescriptor:offset:bytesPerRow:") +} + //////////////////////////////////////////////////////////////////////////////// /* From bef806bef479c5a7b952369ca07538952813e2fe Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 14:24:36 +0000 Subject: [PATCH 36/64] Update Capture Manager classes --- core/sys/darwin/Metal/MetalClasses.odin | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index c025778ea..6ce2d940d 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -1077,8 +1077,8 @@ CaptureDescriptor_init :: #force_inline proc(self: ^CaptureDescriptor) -> ^Captu return msgSend(^CaptureDescriptor, self, "init") } @(objc_type=CaptureDescriptor, objc_name="captureObject") -CaptureDescriptor_captureObject :: #force_inline proc(self: ^CaptureDescriptor) -> ^CaptureDescriptor { - return msgSend(^CaptureDescriptor, self, "captureObject") +CaptureDescriptor_captureObject :: #force_inline proc(self: ^CaptureDescriptor) -> id { + return msgSend(id, self, "captureObject") } @(objc_type=CaptureDescriptor, objc_name="destination") CaptureDescriptor_destination :: #force_inline proc(self: ^CaptureDescriptor) -> CaptureDestination { @@ -1143,12 +1143,12 @@ CaptureManager_isCapturing :: #force_inline proc(self: ^CaptureManager) -> BOOL return msgSend(BOOL, self, "isCapturing") } @(objc_type=CaptureManager, objc_name="newCaptureScopeWithCommandQueue") -CaptureManager_newCaptureScopeWithCommandQueue :: #force_inline proc(self: ^CaptureManager, commandQueue: ^CommandQueue) -> ^CaptureManager { - return msgSend(^CaptureManager, self, "newCaptureScopeWithCommandQueue:", commandQueue) +CaptureManager_newCaptureScopeWithCommandQueue :: #force_inline proc(self: ^CaptureManager, commandQueue: ^CommandQueue) -> ^CaptureScope { + return msgSend(^CaptureScope, self, "newCaptureScopeWithCommandQueue:", commandQueue) } @(objc_type=CaptureManager, objc_name="newCaptureScopeWithDevice") -CaptureManager_newCaptureScopeWithDevice :: #force_inline proc(self: ^CaptureManager, device: ^Device) -> ^CaptureManager { - return msgSend(^CaptureManager, self, "newCaptureScopeWithDevice:", device) +CaptureManager_newCaptureScopeWithDevice :: #force_inline proc(self: ^CaptureManager, device: ^Device) -> ^CaptureScope { + return msgSend(^CaptureScope, self, "newCaptureScopeWithDevice:", device) } @(objc_type=CaptureManager, objc_name="setDefaultCaptureScope") CaptureManager_setDefaultCaptureScope :: #force_inline proc(self: ^CaptureManager, defaultCaptureScope: ^CaptureScope) { From f9fc4883990d879b28361b308fc1406244756d16 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 14:26:35 +0000 Subject: [PATCH 37/64] Correct CaptureScope --- core/sys/darwin/Metal/MetalClasses.odin | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 6ce2d940d..b11c8f73d 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -5552,12 +5552,12 @@ CaptureScope_beginScope :: #force_inline proc(self: ^CaptureScope) { msgSend(nil, self, "beginScope") } @(objc_type=CaptureScope, objc_name="commandQueue") -CaptureScope_commandQueue :: #force_inline proc(self: ^CaptureScope) -> ^CaptureScope { - return msgSend(^CaptureScope, self, "commandQueue") +CaptureScope_commandQueue :: #force_inline proc(self: ^CaptureScope) -> ^CommandQueue { + return msgSend(^CommandQueue, self, "commandQueue") } @(objc_type=CaptureScope, objc_name="device") -CaptureScope_device :: #force_inline proc(self: ^CaptureScope) -> ^CaptureScope { - return msgSend(^CaptureScope, self, "device") +CaptureScope_device :: #force_inline proc(self: ^CaptureScope) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=CaptureScope, objc_name="endScope") CaptureScope_endScope :: #force_inline proc(self: ^CaptureScope) { From a88d1499035cfcf733d4269ec75546e98eb5f893 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 14:33:02 +0000 Subject: [PATCH 38/64] Improve CommandBuffer --- core/sys/darwin/Metal/MetalClasses.odin | 30 ++++++++++++++++--------- 1 file changed, 20 insertions(+), 10 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index b11c8f73d..6ca13c644 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -5656,20 +5656,20 @@ CommandBuffer_commit :: #force_inline proc(self: ^CommandBuffer) { msgSend(nil, self, "commit") } @(objc_type=CommandBuffer, objc_name="computeCommandEncoder") -CommandBuffer_computeCommandEncoder :: #force_inline proc(self: ^CommandBuffer) -> ^CommandEncoder { - return msgSend(^CommandEncoder, self, "computeCommandEncoder") +CommandBuffer_computeCommandEncoder :: #force_inline proc(self: ^CommandBuffer) -> ^ComputeCommandEncoder { + return msgSend(^ComputeCommandEncoder, self, "computeCommandEncoder") } @(objc_type=CommandBuffer, objc_name="computeCommandEncoderWithDescriptor") -CommandBuffer_computeCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, computePassDescriptor: ^ComputePassDescriptor) -> ^CommandEncoder { - return msgSend(^CommandEncoder, self, "computeCommandEncoderWithDescriptor:", computePassDescriptor) +CommandBuffer_computeCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, computePassDescriptor: ^ComputePassDescriptor) -> ^ComputeCommandEncoder { + return msgSend(^ComputeCommandEncoder, self, "computeCommandEncoderWithDescriptor:", computePassDescriptor) } @(objc_type=CommandBuffer, objc_name="computeCommandEncoderWithDispatchType") -CommandBuffer_computeCommandEncoderWithDispatchType :: #force_inline proc(self: ^CommandBuffer, dispatchType: DispatchType) -> ^CommandEncoder { - return msgSend(^CommandEncoder, self, "computeCommandEncoderWithDispatchType:", dispatchType) +CommandBuffer_computeCommandEncoderWithDispatchType :: #force_inline proc(self: ^CommandBuffer, dispatchType: DispatchType) -> ^ComputeCommandEncoder { + return msgSend(^ComputeCommandEncoder, self, "computeCommandEncoderWithDispatchType:", dispatchType) } @(objc_type=CommandBuffer, objc_name="device") -CommandBuffer_device :: #force_inline proc(self: ^CommandBuffer) -> ^CommandBuffer { - return msgSend(^CommandBuffer, self, "device") +CommandBuffer_device :: #force_inline proc(self: ^CommandBuffer) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=CommandBuffer, objc_name="encodeSignalEvent") CommandBuffer_encodeSignalEvent :: #force_inline proc(self: ^CommandBuffer, event: ^Event, value: u64) { @@ -5704,8 +5704,8 @@ CommandBuffer_label :: #force_inline proc(self: ^CommandBuffer) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=CommandBuffer, objc_name="logs") -CommandBuffer_logs :: #force_inline proc(self: ^CommandBuffer) -> id { - return msgSend(id, self, "logs") +CommandBuffer_logs :: #force_inline proc(self: ^CommandBuffer) -> ^LogContainer { + return msgSend(^LogContainer, self, "logs") } @(objc_type=CommandBuffer, objc_name="parallelRenderCommandEncoderWithDescriptor") CommandBuffer_parallelRenderCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, renderPassDescriptor: ^RenderPassDescriptor) -> ^ParallelRenderCommandEncoder { @@ -6975,6 +6975,16 @@ FunctionHandle_name :: #force_inline proc(self: ^FunctionHandle) -> ^NS.String { //////////////////////////////////////////////////////////////////////////////// +/* +Class: + LogContainer +*/ + +@(objc_class="MTLLogContainer") +LogContainer :: struct { using _: NS.FastEnumeration } + +//////////////////////////////////////////////////////////////////////////////// + /* Class: FunctionLog From 6fef44c041762d5ef552e793006ee36de2a227fe Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 14:33:50 +0000 Subject: [PATCH 39/64] Improve CommandEncoder --- core/sys/darwin/Metal/MetalClasses.odin | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 6ca13c644..868ac2498 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -5810,8 +5810,8 @@ Methods: CommandEncoder :: struct { using _: NS.Object } @(objc_type=CommandEncoder, objc_name="device") -CommandEncoder_device :: #force_inline proc(self: ^CommandEncoder) -> ^CommandEncoder { - return msgSend(^CommandEncoder, self, "device") +CommandEncoder_device :: #force_inline proc(self: ^CommandEncoder) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=CommandEncoder, objc_name="endEncoding") CommandEncoder_endEncoding :: #force_inline proc(self: ^CommandEncoder) { From 153140eb8f5b3c2e5a4f90dd6caf7b34a46e77de Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 14:43:50 +0000 Subject: [PATCH 40/64] Improve ComputeCommandEncoder --- core/sys/darwin/Metal/MetalClasses.odin | 46 +++++++++++-------------- 1 file changed, 21 insertions(+), 25 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 868ac2498..f849338cc 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -5203,7 +5203,6 @@ ArgumentEncoder_setComputePipelineState :: #force_inline proc(self: ^ArgumentEnc } @(objc_type=ArgumentEncoder, objc_name="setComputePipelineStates") ArgumentEncoder_setComputePipelineStates :: #force_inline proc(self: ^ArgumentEncoder, pipelines: []^ComputePipelineState, range: NS.Range) { - assert(range.location < NS.UInteger(len(pipelines))) assert(range.length <= NS.UInteger(len(pipelines))) msgSend(nil, self, "setComputePipelineStates:withRange:", raw_data(pipelines), range) } @@ -5213,7 +5212,6 @@ ArgumentEncoder_setIndirectCommandBuffer :: #force_inline proc(self: ^ArgumentEn } @(objc_type=ArgumentEncoder, objc_name="setIndirectCommandBuffers") ArgumentEncoder_setIndirectCommandBuffers :: #force_inline proc(self: ^ArgumentEncoder, buffers: []^IndirectCommandBuffer, range: NS.Range) { - assert(range.location < NS.UInteger(len(buffers))) assert(range.length <= NS.UInteger(len(buffers))) msgSend(nil, self, "setIndirectCommandBuffers:withRange:", raw_data(buffers), range) } @@ -5223,7 +5221,6 @@ ArgumentEncoder_setIntersectionFunctionTable :: #force_inline proc(self: ^Argume } @(objc_type=ArgumentEncoder, objc_name="setIntersectionFunctionTables") ArgumentEncoder_setIntersectionFunctionTables :: #force_inline proc(self: ^ArgumentEncoder, intersectionFunctionTables: []^IntersectionFunctionTable, range: NS.Range) { - assert(range.location < NS.UInteger(len(intersectionFunctionTables))) assert(range.length <= NS.UInteger(len(intersectionFunctionTables))) msgSend(nil, self, "setIntersectionFunctionTables:withRange:", raw_data(intersectionFunctionTables), range) } @@ -5237,7 +5234,6 @@ ArgumentEncoder_setRenderPipelineState :: #force_inline proc(self: ^ArgumentEnco } @(objc_type=ArgumentEncoder, objc_name="setRenderPipelineStates") ArgumentEncoder_setRenderPipelineStates :: #force_inline proc(self: ^ArgumentEncoder, pipelines: []^RenderPipelineState, range: NS.Range) { - assert(range.location < NS.UInteger(len(pipelines))) assert(range.length <= NS.UInteger(len(pipelines))) msgSend(nil, self, "setRenderPipelineStates:withRange:", raw_data(pipelines), range) } @@ -5247,7 +5243,6 @@ ArgumentEncoder_setSamplerState :: #force_inline proc(self: ^ArgumentEncoder, sa } @(objc_type=ArgumentEncoder, objc_name="setSamplerStates") ArgumentEncoder_setSamplerStates :: #force_inline proc(self: ^ArgumentEncoder, samplers: []^SamplerState, range: NS.Range) { - assert(range.location < NS.UInteger(len(samplers))) assert(range.length <= NS.UInteger(len(samplers))) msgSend(nil, self, "setSamplerStates:withRange:", raw_data(samplers), range) } @@ -5257,7 +5252,6 @@ ArgumentEncoder_setTexture :: #force_inline proc(self: ^ArgumentEncoder, texture } @(objc_type=ArgumentEncoder, objc_name="setTextures") ArgumentEncoder_setTextures :: #force_inline proc(self: ^ArgumentEncoder, textures: []^Texture, range: NS.Range) { - assert(range.location < NS.UInteger(len(textures))) assert(range.length <= NS.UInteger(len(textures))) msgSend(nil, self, "setTextures:withRange:", raw_data(textures), range) } @@ -5267,7 +5261,6 @@ ArgumentEncoder_setVisibleFunctionTable :: #force_inline proc(self: ^ArgumentEnc } @(objc_type=ArgumentEncoder, objc_name="setVisibleFunctionTables") ArgumentEncoder_setVisibleFunctionTables :: #force_inline proc(self: ^ArgumentEncoder, visibleFunctionTables: []^VisibleFunctionTable, range: NS.Range) { - assert(range.location < NS.UInteger(len(visibleFunctionTables))) assert(range.length <= NS.UInteger(len(visibleFunctionTables))) msgSend(nil, self, "setVisibleFunctionTables:withRange:", raw_data(visibleFunctionTables), range) } @@ -5956,8 +5949,8 @@ ComputeCommandEncoder_executeCommandsInBufferWithRange :: #force_inline proc(sel msgSend(nil, self, "executeCommandsInBuffer:withRange:", indirectCommandBuffer, executionRange) } @(objc_type=ComputeCommandEncoder, objc_name="memoryBarrierWithResources") -ComputeCommandEncoder_memoryBarrierWithResources :: #force_inline proc(self: ^ComputeCommandEncoder, resources: [^]^Resource, count: NS.UInteger) { - msgSend(nil, self, "memoryBarrierWithResources:count:", resources, count) +ComputeCommandEncoder_memoryBarrierWithResources :: #force_inline proc(self: ^ComputeCommandEncoder, resources: []^Resource) { + msgSend(nil, self, "memoryBarrierWithResources:count:", raw_data(resources), NS.UInteger(len(resources))) } @(objc_type=ComputeCommandEncoder, objc_name="memoryBarrierWithScope") ComputeCommandEncoder_memoryBarrierWithScope :: #force_inline proc(self: ^ComputeCommandEncoder, scope: BarrierScope) { @@ -5980,8 +5973,10 @@ ComputeCommandEncoder_setBufferOffset :: #force_inline proc(self: ^ComputeComman msgSend(nil, self, "setBufferOffset:atIndex:", offset, index) } @(objc_type=ComputeCommandEncoder, objc_name="setBuffers") -ComputeCommandEncoder_setBuffers :: #force_inline proc(self: ^ComputeCommandEncoder, buffers: [^]^Buffer, offsets: [^]NS.UInteger, range: NS.Range) { - msgSend(nil, self, "setBuffers:offsets:withRange:", buffers, offsets, range) +ComputeCommandEncoder_setBuffers :: #force_inline proc(self: ^ComputeCommandEncoder, buffers: []^Buffer, offsets: []NS.UInteger, range: NS.Range) { + assert(len(buffers) == len(offsets)) + assert(range.length <= NS.UInteger(len(buffers))) + msgSend(nil, self, "setBuffers:offsets:withRange:", raw_data(buffers), raw_data(offsets), range) } @(objc_type=ComputeCommandEncoder, objc_name="setBytes") ComputeCommandEncoder_setBytes :: #force_inline proc(self: ^ComputeCommandEncoder, bytes: rawptr, length: NS.UInteger, index: NS.UInteger) { @@ -6000,8 +5995,9 @@ ComputeCommandEncoder_setIntersectionFunctionTable :: #force_inline proc(self: ^ msgSend(nil, self, "setIntersectionFunctionTable:atBufferIndex:", intersectionFunctionTable, bufferIndex) } @(objc_type=ComputeCommandEncoder, objc_name="setIntersectionFunctionTables") -ComputeCommandEncoder_setIntersectionFunctionTables :: #force_inline proc(self: ^ComputeCommandEncoder, intersectionFunctionTables: [^]^IntersectionFunctionTable, range: NS.Range) { - msgSend(nil, self, "setIntersectionFunctionTables:withBufferRange:", intersectionFunctionTables, range) +ComputeCommandEncoder_setIntersectionFunctionTables :: #force_inline proc(self: ^ComputeCommandEncoder, intersectionFunctionTables: []^IntersectionFunctionTable, range: NS.Range) { + assert(range.length <= NS.UInteger(len(intersectionFunctionTables))) + msgSend(nil, self, "setIntersectionFunctionTables:withBufferRange:", raw_data(intersectionFunctionTables), range) } @(objc_type=ComputeCommandEncoder, objc_name="setSamplerStateAtIndex") ComputeCommandEncoder_setSamplerStateAtIndex :: #force_inline proc(self: ^ComputeCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { @@ -6012,12 +6008,12 @@ ComputeCommandEncoder_setSamplerState_lodMinClamp_lodMaxClampAtIndex :: #force_i msgSend(nil, self, "setSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } @(objc_type=ComputeCommandEncoder, objc_name="setSamplerStates_lodMinClamps_lodMaxClampsWithRange") -ComputeCommandEncoder_setSamplerStates_lodMinClamps_lodMaxClampsWithRange :: #force_inline proc(self: ^ComputeCommandEncoder, samplers: [^]^SamplerState, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { - msgSend(nil, self, "setSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range) +ComputeCommandEncoder_setSamplerStates_lodMinClamps_lodMaxClampsWithRange :: #force_inline proc(self: ^ComputeCommandEncoder, samplers: []^SamplerState, lodMinClamps, lodMaxClamps: []f32, range: NS.Range) { + msgSend(nil, self, "setSamplerStates:lodMinClamps:lodMaxClamps:withRange:", raw_data(samplers), raw_data(lodMinClamps), raw_data(lodMaxClamps), range) } @(objc_type=ComputeCommandEncoder, objc_name="setSamplerStatesWithRange") -ComputeCommandEncoder_setSamplerStatesWithRange :: #force_inline proc(self: ^ComputeCommandEncoder, samplers: [^]^SamplerState, range: NS.Range) { - msgSend(nil, self, "setSamplerStates:withRange:", samplers, range) +ComputeCommandEncoder_setSamplerStatesWithRange :: #force_inline proc(self: ^ComputeCommandEncoder, samplers: []^SamplerState, range: NS.Range) { + msgSend(nil, self, "setSamplerStates:withRange:", raw_data(samplers), range) } @(objc_type=ComputeCommandEncoder, objc_name="setStageInRegion") ComputeCommandEncoder_setStageInRegion :: #force_inline proc(self: ^ComputeCommandEncoder, region: Region) { @@ -6032,8 +6028,8 @@ ComputeCommandEncoder_setTexture :: #force_inline proc(self: ^ComputeCommandEnco msgSend(nil, self, "setTexture:atIndex:", texture, index) } @(objc_type=ComputeCommandEncoder, objc_name="setTextures") -ComputeCommandEncoder_setTextures :: #force_inline proc(self: ^ComputeCommandEncoder, textures: [^]^Texture, range: NS.Range) { - msgSend(nil, self, "setTextures:withRange:", textures, range) +ComputeCommandEncoder_setTextures :: #force_inline proc(self: ^ComputeCommandEncoder, textures: []^Texture, range: NS.Range) { + msgSend(nil, self, "setTextures:withRange:", raw_data(textures), range) } @(objc_type=ComputeCommandEncoder, objc_name="setThreadgroupMemoryLength") ComputeCommandEncoder_setThreadgroupMemoryLength :: #force_inline proc(self: ^ComputeCommandEncoder, length: NS.UInteger, index: NS.UInteger) { @@ -6044,8 +6040,8 @@ ComputeCommandEncoder_setVisibleFunctionTable :: #force_inline proc(self: ^Compu msgSend(nil, self, "setVisibleFunctionTable:atBufferIndex:", visibleFunctionTable, bufferIndex) } @(objc_type=ComputeCommandEncoder, objc_name="setVisibleFunctionTables") -ComputeCommandEncoder_setVisibleFunctionTables :: #force_inline proc(self: ^ComputeCommandEncoder, visibleFunctionTables: [^]^VisibleFunctionTable, range: NS.Range) { - msgSend(nil, self, "setVisibleFunctionTables:withBufferRange:", visibleFunctionTables, range) +ComputeCommandEncoder_setVisibleFunctionTables :: #force_inline proc(self: ^ComputeCommandEncoder, visibleFunctionTables: []^VisibleFunctionTable, range: NS.Range) { + msgSend(nil, self, "setVisibleFunctionTables:withBufferRange:", raw_data(visibleFunctionTables), range) } @(objc_type=ComputeCommandEncoder, objc_name="updateFence") ComputeCommandEncoder_updateFence :: #force_inline proc(self: ^ComputeCommandEncoder, fence: ^Fence) { @@ -6056,16 +6052,16 @@ ComputeCommandEncoder_useHeap :: #force_inline proc(self: ^ComputeCommandEncoder msgSend(nil, self, "useHeap:", heap) } @(objc_type=ComputeCommandEncoder, objc_name="useHeaps") -ComputeCommandEncoder_useHeaps :: #force_inline proc(self: ^ComputeCommandEncoder, heaps: [^]^Heap, count: NS.UInteger) { - msgSend(nil, self, "useHeaps:count:", heaps, count) +ComputeCommandEncoder_useHeaps :: #force_inline proc(self: ^ComputeCommandEncoder, heaps: []^Heap) { + msgSend(nil, self, "useHeaps:count:", raw_data(heaps), NS.UInteger(len(heaps))) } @(objc_type=ComputeCommandEncoder, objc_name="useResource") ComputeCommandEncoder_useResource :: #force_inline proc(self: ^ComputeCommandEncoder, resource: ^Resource, usage: ResourceUsage) { msgSend(nil, self, "useResource:usage:", resource, usage) } @(objc_type=ComputeCommandEncoder, objc_name="useResources") -ComputeCommandEncoder_useResources :: #force_inline proc(self: ^ComputeCommandEncoder, resources: [^]^Resource, count: NS.UInteger, usage: ResourceUsage) { - msgSend(nil, self, "useResources:count:usage:", resources, count, usage) +ComputeCommandEncoder_useResources :: #force_inline proc(self: ^ComputeCommandEncoder, resources: []^Resource, usage: ResourceUsage) { + msgSend(nil, self, "useResources:count:usage:", raw_data(resources), NS.UInteger(len(resources)), usage) } @(objc_type=ComputeCommandEncoder, objc_name="waitForFence") ComputeCommandEncoder_waitForFence :: #force_inline proc(self: ^ComputeCommandEncoder, fence: ^Fence) { From af6e53c05c462a6a5cfe060509c954c5eccd9fe5 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 15:14:41 +0000 Subject: [PATCH 41/64] Improve Compute classes --- core/sys/darwin/Metal/MetalClasses.odin | 80 ++++++++++++------------- 1 file changed, 40 insertions(+), 40 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index f849338cc..be706212f 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -1392,8 +1392,8 @@ ComputePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_in return msgSend(NS.UInteger, self, "endOfEncoderSampleIndex") } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") -ComputePassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> ^Buffer { - return msgSend(^Buffer, self, "sampleBuffer") +ComputePassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> ^CounterSampleBuffer { + return msgSend(^CounterSampleBuffer, self, "sampleBuffer") } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex") ComputePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.UInteger) { @@ -1498,8 +1498,8 @@ ComputePipelineDescriptor_buffers :: #force_inline proc(self: ^ComputePipelineDe return msgSend(^PipelineBufferDescriptorArray, self, "buffers") } @(objc_type=ComputePipelineDescriptor, objc_name="computeFunction") -ComputePipelineDescriptor_computeFunction :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ^ComputePipelineDescriptor { - return msgSend(^ComputePipelineDescriptor, self, "computeFunction") +ComputePipelineDescriptor_computeFunction :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ^Function { + return msgSend(^Function, self, "computeFunction") } @(objc_type=ComputePipelineDescriptor, objc_name="insertLibraries") ComputePipelineDescriptor_insertLibraries :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ^NS.Array { @@ -2647,8 +2647,8 @@ RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSizeWithL return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:layer:", screenSize, layer) } @(objc_type=RasterizationRateMapDescriptor, objc_class_name="rasterizationRateMapDescriptorWithScreenSizeWithLayers") -RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSizeWithLayers :: #force_inline proc(screenSize: Size, layerCount: NS.UInteger, layers: [^]^RasterizationRateLayerDescriptor) -> ^RasterizationRateMapDescriptor { - return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:layerCount:layers:", screenSize, layerCount, layers) +RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSizeWithLayers :: #force_inline proc(screenSize: Size, layers: []^RasterizationRateLayerDescriptor) -> ^RasterizationRateMapDescriptor { + return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:layerCount:layers:", screenSize, NS.UInteger(len(layers)), layers) } @(objc_type=RasterizationRateMapDescriptor, objc_name="screenSize") RasterizationRateMapDescriptor_screenSize :: #force_inline proc(self: ^RasterizationRateMapDescriptor) -> Size { @@ -6091,12 +6091,12 @@ Methods: ComputePipelineState :: struct { using _: NS.Object } @(objc_type=ComputePipelineState, objc_name="device") -ComputePipelineState_device :: #force_inline proc(self: ^ComputePipelineState) -> ^ComputePipelineState { - return msgSend(^ComputePipelineState, self, "device") +ComputePipelineState_device :: #force_inline proc(self: ^ComputePipelineState) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=ComputePipelineState, objc_name="functionHandleWithFunction") -ComputePipelineState_functionHandleWithFunction :: #force_inline proc(self: ^ComputePipelineState, function: ^Function) -> ^ComputePipelineState { - return msgSend(^ComputePipelineState, self, "functionHandleWithFunction:", function) +ComputePipelineState_functionHandleWithFunction :: #force_inline proc(self: ^ComputePipelineState, function: ^Function) -> ^FunctionHandle { + return msgSend(^FunctionHandle, self, "functionHandleWithFunction:", function) } @(objc_type=ComputePipelineState, objc_name="imageblockMemoryLengthForDimensions") ComputePipelineState_imageblockMemoryLengthForDimensions :: #force_inline proc(self: ^ComputePipelineState, imageblockDimensions: Size) -> ^ComputePipelineState { @@ -6110,18 +6110,18 @@ ComputePipelineState_label :: #force_inline proc(self: ^ComputePipelineState) -> ComputePipelineState_maxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^ComputePipelineState) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxTotalThreadsPerThreadgroup") } -@(objc_type=ComputePipelineState, objc_name="newComputePipelineStateWithAdditionalBinaryFunctions") -ComputePipelineState_newComputePipelineStateWithAdditionalBinaryFunctions :: #force_inline proc(self: ^ComputePipelineState, functions: ^NS.Array) -> (state: ^ComputePipelineState, error: ^NS.Error) { +@(objc_type=ComputePipelineState, objc_name="newComputePipelineState") +ComputePipelineState_newComputePipelineState :: #force_inline proc(self: ^ComputePipelineState, functions: ^NS.Array) -> (state: ^ComputePipelineState, error: ^NS.Error) { state = msgSend(^ComputePipelineState, self, "newComputePipelineStateWithAdditionalBinaryFunctions:error:", functions, &error) return } -@(objc_type=ComputePipelineState, objc_name="newIntersectionFunctionTableWithDescriptor") -ComputePipelineState_newIntersectionFunctionTableWithDescriptor :: #force_inline proc(self: ^ComputePipelineState, descriptor: ^IntersectionFunctionTableDescriptor) -> ^ComputePipelineState { - return msgSend(^ComputePipelineState, self, "newIntersectionFunctionTableWithDescriptor:", descriptor) +@(objc_type=ComputePipelineState, objc_name="newIntersectionFunctionTable") +ComputePipelineState_newIntersectionFunctionTable :: #force_inline proc(self: ^ComputePipelineState, descriptor: ^IntersectionFunctionTableDescriptor) -> ^IntersectionFunctionTable { + return msgSend(^IntersectionFunctionTable, self, "newIntersectionFunctionTableWithDescriptor:", descriptor) } -@(objc_type=ComputePipelineState, objc_name="newVisibleFunctionTableWithDescriptor") -ComputePipelineState_newVisibleFunctionTableWithDescriptor :: #force_inline proc(self: ^ComputePipelineState, descriptor: ^VisibleFunctionTableDescriptor) -> ^ComputePipelineState { - return msgSend(^ComputePipelineState, self, "newVisibleFunctionTableWithDescriptor:", descriptor) +@(objc_type=ComputePipelineState, objc_name="newVisibleFunctionTable") +ComputePipelineState_newVisibleFunctionTable :: #force_inline proc(self: ^ComputePipelineState, descriptor: ^VisibleFunctionTableDescriptor) -> ^VisibleFunctionTable { + return msgSend(^VisibleFunctionTable, self, "newVisibleFunctionTableWithDescriptor:", descriptor) } @(objc_type=ComputePipelineState, objc_name="staticThreadgroupMemoryLength") ComputePipelineState_staticThreadgroupMemoryLength :: #force_inline proc(self: ^ComputePipelineState) -> NS.UInteger { @@ -7310,16 +7310,16 @@ IntersectionFunctionTable_setBuffer :: #force_inline proc(self: ^IntersectionFun msgSend(nil, self, "setBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=IntersectionFunctionTable, objc_name="setBuffers") -IntersectionFunctionTable_setBuffers :: #force_inline proc(self: ^IntersectionFunctionTable, buffers: [^]^Buffer, offsets: [^]NS.UInteger, range: NS.Range) { - msgSend(nil, self, "setBuffers:offsets:withRange:", buffers, offsets, range) +IntersectionFunctionTable_setBuffers :: #force_inline proc(self: ^IntersectionFunctionTable, buffers: []^Buffer, offsets: []NS.UInteger, range: NS.Range) { + msgSend(nil, self, "setBuffers:offsets:withRange:", raw_data(buffers), raw_data(offsets), range) } @(objc_type=IntersectionFunctionTable, objc_name="setFunction") IntersectionFunctionTable_setFunction :: #force_inline proc(self: ^IntersectionFunctionTable, function: ^FunctionHandle, index: NS.UInteger) { msgSend(nil, self, "setFunction:atIndex:", function, index) } @(objc_type=IntersectionFunctionTable, objc_name="setFunctions") -IntersectionFunctionTable_setFunctions :: #force_inline proc(self: ^IntersectionFunctionTable, functions: [^]^FunctionHandle, range: NS.Range) { - msgSend(nil, self, "setFunctions:withRange:", functions, range) +IntersectionFunctionTable_setFunctions :: #force_inline proc(self: ^IntersectionFunctionTable, functions: []^FunctionHandle, range: NS.Range) { + msgSend(nil, self, "setFunctions:withRange:", raw_data(functions), range) } @(objc_type=IntersectionFunctionTable, objc_name="setOpaqueTriangleIntersectionFunctionWithSignatureAtIndex") IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignatureAtIndex :: #force_inline proc(self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, index: NS.UInteger) { @@ -7334,8 +7334,8 @@ IntersectionFunctionTable_setVisibleFunctionTable :: #force_inline proc(self: ^I msgSend(nil, self, "setVisibleFunctionTable:atBufferIndex:", visibleFunctionTable, bufferIndex) } @(objc_type=IntersectionFunctionTable, objc_name="setVisibleFunctionTables") -IntersectionFunctionTable_setVisibleFunctionTables :: #force_inline proc(self: ^IntersectionFunctionTable, visibleFunctionTables: [^]^VisibleFunctionTable, range: NS.Range) { - msgSend(nil, self, "setVisibleFunctionTables:withBufferRange:", visibleFunctionTables, range) +IntersectionFunctionTable_setVisibleFunctionTables :: #force_inline proc(self: ^IntersectionFunctionTable, visibleFunctionTables: []^VisibleFunctionTable, range: NS.Range) { + msgSend(nil, self, "setVisibleFunctionTables:withBufferRange:", raw_data(visibleFunctionTables), range) } //////////////////////////////////////////////////////////////////////////////// @@ -7685,8 +7685,8 @@ RenderCommandEncoder_executeCommandsInBufferWithRange :: #force_inline proc(self msgSend(nil, self, "executeCommandsInBuffer:withRange:", indirectCommandBuffer, executionRange) } @(objc_type=RenderCommandEncoder, objc_name="memoryBarrierWithResources") -RenderCommandEncoder_memoryBarrierWithResources :: #force_inline proc(self: ^RenderCommandEncoder, resources: [^]^Resource, count: NS.UInteger, after: RenderStages, before: RenderStages) { - msgSend(nil, self, "memoryBarrierWithResources:count:afterStages:beforeStages:", resources, count, after, before) +RenderCommandEncoder_memoryBarrierWithResources :: #force_inline proc(self: ^RenderCommandEncoder, resources: []^Resource, after: RenderStages, before: RenderStages) { + msgSend(nil, self, "memoryBarrierWithResources:count:afterStages:beforeStages:", raw_data(resources), NS.UInteger(len(resources)), after, before) } @(objc_type=RenderCommandEncoder, objc_name="memoryBarrierWithScope") RenderCommandEncoder_memoryBarrierWithScope :: #force_inline proc(self: ^RenderCommandEncoder, scope: BarrierScope, after: RenderStages, before: RenderStages) { @@ -7741,12 +7741,12 @@ RenderCommandEncoder_setFragmentBufferOffset :: #force_inline proc(self: ^Render msgSend(nil, self, "setFragmentBufferOffset:atIndex:", offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentBuffers") -RenderCommandEncoder_setFragmentBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: [^]^Buffer, offsets: [^]NS.UInteger, range: NS.Range) { - msgSend(nil, self, "setFragmentBuffers:offsets:withRange:", buffers, offsets, range) +RenderCommandEncoder_setFragmentBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: []^Buffer, offsets: []NS.UInteger, range: NS.Range) { + msgSend(nil, self, "setFragmentBuffers:offsets:withRange:", raw_data(buffers), raw_data(offsets), range) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentBytes") -RenderCommandEncoder_setFragmentBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: rawptr, length: NS.UInteger, index: NS.UInteger) { - msgSend(nil, self, "setFragmentBytes:length:atIndex:", bytes, length, index) +RenderCommandEncoder_setFragmentBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: []byte, index: NS.UInteger) { + msgSend(nil, self, "setFragmentBytes:length:atIndex:", raw_data(bytes), NS.UInteger(len(bytes)), index) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStateAtIndex") RenderCommandEncoder_setFragmentSamplerStateAtIndex :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { @@ -7757,20 +7757,20 @@ RenderCommandEncoder_setFragmentSamplerState_lodMinClamp_lodMaxClampAtIndex :: # msgSend(nil, self, "setFragmentSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStates_lodMinClamps_lodMaxClampsWithRange") -RenderCommandEncoder_setFragmentSamplerStates_lodMinClamps_lodMaxClampsWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: [^]^SamplerState, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { - msgSend(nil, self, "setFragmentSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range) +RenderCommandEncoder_setFragmentSamplerStates_lodMinClamps_lodMaxClampsWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: []^SamplerState, lodMinClamps: []f32, lodMaxClamps: []f32, range: NS.Range) { + msgSend(nil, self, "setFragmentSamplerStates:lodMinClamps:lodMaxClamps:withRange:", raw_data(samplers), raw_data(lodMinClamps), raw_data(lodMaxClamps), range) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStatesWithRange") -RenderCommandEncoder_setFragmentSamplerStatesWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: [^]^SamplerState, range: NS.Range) { - msgSend(nil, self, "setFragmentSamplerStates:withRange:", samplers, range) +RenderCommandEncoder_setFragmentSamplerStatesWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: []^SamplerState, range: NS.Range) { + msgSend(nil, self, "setFragmentSamplerStates:withRange:", raw_data(samplers), range) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentTexture") RenderCommandEncoder_setFragmentTexture :: #force_inline proc(self: ^RenderCommandEncoder, texture: ^Texture, index: NS.UInteger) { msgSend(nil, self, "setFragmentTexture:atIndex:", texture, index) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentTextures") -RenderCommandEncoder_setFragmentTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: [^]^Texture, range: NS.Range) { - msgSend(nil, self, "setFragmentTextures:withRange:", textures, range) +RenderCommandEncoder_setFragmentTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: []^Texture, range: NS.Range) { + msgSend(nil, self, "setFragmentTextures:withRange:", raw_data(textures), range) } @(objc_type=RenderCommandEncoder, objc_name="setFrontFacingWinding") RenderCommandEncoder_setFrontFacingWinding :: #force_inline proc(self: ^RenderCommandEncoder, frontFacingWinding: Winding) { @@ -7785,8 +7785,8 @@ RenderCommandEncoder_setScissorRect :: #force_inline proc(self: ^RenderCommandEn msgSend(nil, self, "setScissorRect:", rect) } @(objc_type=RenderCommandEncoder, objc_name="setScissorRects") -RenderCommandEncoder_setScissorRects :: #force_inline proc(self: ^RenderCommandEncoder, scissorRects: ^ScissorRect, count: NS.UInteger) { - msgSend(nil, self, "setScissorRects:count:", scissorRects, count) +RenderCommandEncoder_setScissorRects :: #force_inline proc(self: ^RenderCommandEncoder, scissorRects: []ScissorRect) { + msgSend(nil, self, "setScissorRects:count:", raw_data(scissorRects), NS.UInteger(len(scissorRects))) } @(objc_type=RenderCommandEncoder, objc_name="setStencilFrontReferenceValue") RenderCommandEncoder_setStencilFrontReferenceValue :: #force_inline proc(self: ^RenderCommandEncoder, frontReferenceValue: u32, backReferenceValue: u32) { @@ -7861,8 +7861,8 @@ RenderCommandEncoder_setTriangleFillMode :: #force_inline proc(self: ^RenderComm msgSend(nil, self, "setTriangleFillMode:", fillMode) } @(objc_type=RenderCommandEncoder, objc_name="setVertexAmplificationCount") -RenderCommandEncoder_setVertexAmplificationCount :: #force_inline proc(self: ^RenderCommandEncoder, count: NS.UInteger, viewMappings: ^VertexAmplificationViewMapping) { - msgSend(nil, self, "setVertexAmplificationCount:viewMappings:", count, viewMappings) +RenderCommandEncoder_setVertexAmplificationCount :: #force_inline proc(self: ^RenderCommandEncoder, viewMappings: []VertexAmplificationViewMapping) { + msgSend(nil, self, "setVertexAmplificationCount:viewMappings:", NS.UInteger(len(viewMappings)), raw_data(viewMappings)) } @(objc_type=RenderCommandEncoder, objc_name="setVertexBuffer") RenderCommandEncoder_setVertexBuffer :: #force_inline proc(self: ^RenderCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { From 31c6ecad347985d3e0bc104e3151f70fa9dbb843 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 15:15:32 +0000 Subject: [PATCH 42/64] Correct Counter classes --- core/sys/darwin/Metal/MetalClasses.odin | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index be706212f..ea0cf2682 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -1643,8 +1643,8 @@ CounterSampleBufferDescriptor_init :: #force_inline proc(self: ^CounterSampleBuf return msgSend(^CounterSampleBufferDescriptor, self, "init") } @(objc_type=CounterSampleBufferDescriptor, objc_name="counterSet") -CounterSampleBufferDescriptor_counterSet :: #force_inline proc(self: ^CounterSampleBufferDescriptor) -> ^CounterSampleBufferDescriptor { - return msgSend(^CounterSampleBufferDescriptor, self, "counterSet") +CounterSampleBufferDescriptor_counterSet :: #force_inline proc(self: ^CounterSampleBufferDescriptor) -> ^CounterSet { + return msgSend(^CounterSet, self, "counterSet") } @(objc_type=CounterSampleBufferDescriptor, objc_name="label") CounterSampleBufferDescriptor_label :: #force_inline proc(self: ^CounterSampleBufferDescriptor) -> ^NS.String { From 47f3773146cd6686da8b73be1dc82c6c1e475a50 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 15:18:38 +0000 Subject: [PATCH 43/64] Correct Depth classes --- core/sys/darwin/Metal/MetalClasses.odin | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index ea0cf2682..895d72839 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -6221,8 +6221,8 @@ Methods: DepthStencilState :: struct { using _: NS.Object } @(objc_type=DepthStencilState, objc_name="device") -DepthStencilState_device :: #force_inline proc(self: ^DepthStencilState) -> ^DepthStencilState { - return msgSend(^DepthStencilState, self, "device") +DepthStencilState_device :: #force_inline proc(self: ^DepthStencilState) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=DepthStencilState, objc_name="label") DepthStencilState_label :: #force_inline proc(self: ^DepthStencilState) -> ^NS.String { From e47953f7cabd2351fea6a3ca96d49c3914cd2cff Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 15:45:02 +0000 Subject: [PATCH 44/64] Improve procedure signature and names --- core/sys/darwin/Metal/MetalClasses.odin | 181 ++++++++++++------------ core/sys/darwin/Metal/MetalTypes.odin | 4 +- 2 files changed, 94 insertions(+), 91 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 895d72839..1f4ae50cb 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -1818,8 +1818,8 @@ FunctionConstantValues_init :: #force_inline proc(self: ^FunctionConstantValues) FunctionConstantValues_reset :: #force_inline proc(self: ^FunctionConstantValues) { msgSend(nil, self, "reset") } -@(objc_type=FunctionConstantValues, objc_name="setConstantValueAtIndex") -FunctionConstantValues_setConstantValueAtIndex :: #force_inline proc(self: ^FunctionConstantValues, value: rawptr, type: DataType, index: NS.UInteger) { +@(objc_type=FunctionConstantValues, objc_name="setConstantValue") +FunctionConstantValues_setConstantValue :: #force_inline proc(self: ^FunctionConstantValues, value: rawptr, type: DataType, index: NS.UInteger) { msgSend(nil, self, "setConstantValue:type:atIndex:", value, type, index) } @(objc_type=FunctionConstantValues, objc_name="setConstantValueWithName") @@ -2626,8 +2626,8 @@ RasterizationRateMapDescriptor_init :: #force_inline proc(self: ^RasterizationRa RasterizationRateMapDescriptor_label :: #force_inline proc(self: ^RasterizationRateMapDescriptor) -> ^NS.String { return msgSend(^NS.String, self, "label") } -@(objc_type=RasterizationRateMapDescriptor, objc_name="layerAtIndex") -RasterizationRateMapDescriptor_layerAtIndex :: #force_inline proc(self: ^RasterizationRateMapDescriptor, layerIndex: NS.UInteger) -> ^RasterizationRateLayerDescriptor { +@(objc_type=RasterizationRateMapDescriptor, objc_name="layer") +RasterizationRateMapDescriptor_layer :: #force_inline proc(self: ^RasterizationRateMapDescriptor, layerIndex: NS.UInteger) -> ^RasterizationRateLayerDescriptor { return msgSend(^RasterizationRateLayerDescriptor, self, "layerAtIndex:", layerIndex) } @(objc_type=RasterizationRateMapDescriptor, objc_name="layerCount") @@ -3000,8 +3000,8 @@ RenderPassDescriptor_depthAttachment :: #force_inline proc(self: ^RenderPassDesc return msgSend(^RenderPassDepthAttachmentDescriptor, self, "depthAttachment") } @(objc_type=RenderPassDescriptor, objc_name="getSamplePositions") -RenderPassDescriptor_getSamplePositions :: #force_inline proc(self: ^RenderPassDescriptor, positions: ^SamplePosition, count: NS.UInteger) -> ^RenderPassDescriptor { - return msgSend(^RenderPassDescriptor, self, "getSamplePositions:count:", positions, count) +RenderPassDescriptor_getSamplePositions :: #force_inline proc(self: ^RenderPassDescriptor, positions: []SamplePosition) -> ^RenderPassDescriptor { + return msgSend(^RenderPassDescriptor, self, "getSamplePositions:count:", raw_data(positions), NS.UInteger(len(positions))) } @(objc_type=RenderPassDescriptor, objc_name="imageblockSampleLength") RenderPassDescriptor_imageblockSampleLength :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.UInteger { @@ -3060,8 +3060,8 @@ RenderPassDescriptor_setRenderTargetWidth :: #force_inline proc(self: ^RenderPas msgSend(nil, self, "setRenderTargetWidth:", renderTargetWidth) } @(objc_type=RenderPassDescriptor, objc_name="setSamplePositions") -RenderPassDescriptor_setSamplePositions :: #force_inline proc(self: ^RenderPassDescriptor, positions: ^SamplePosition, count: NS.UInteger) { - msgSend(nil, self, "setSamplePositions:count:", positions, count) +RenderPassDescriptor_setSamplePositions :: #force_inline proc(self: ^RenderPassDescriptor, positions: []SamplePosition) { + msgSend(nil, self, "setSamplePositions:count:", raw_data(positions), NS.UInteger(len(positions))) } @(objc_type=RenderPassDescriptor, objc_name="setStencilAttachment") RenderPassDescriptor_setStencilAttachment :: #force_inline proc(self: ^RenderPassDescriptor, stencilAttachment: ^RenderPassStencilAttachmentDescriptor) { @@ -5156,8 +5156,8 @@ ArgumentEncoder :: struct { using _: NS.Object } ArgumentEncoder_alignment :: #force_inline proc(self: ^ArgumentEncoder) -> NS.UInteger { return msgSend(NS.UInteger, self, "alignment") } -@(objc_type=ArgumentEncoder, objc_name="constantDataAtIndex") -ArgumentEncoder_constantDataAtIndex :: #force_inline proc(self: ^ArgumentEncoder, index: NS.UInteger) -> rawptr { +@(objc_type=ArgumentEncoder, objc_name="constantData") +ArgumentEncoder_constantData :: #force_inline proc(self: ^ArgumentEncoder, index: NS.UInteger) -> rawptr { return msgSend(rawptr, self, "constantDataAtIndex:", index) } @(objc_type=ArgumentEncoder, objc_name="device") @@ -5172,8 +5172,8 @@ ArgumentEncoder_encodedLength :: #force_inline proc(self: ^ArgumentEncoder) -> N ArgumentEncoder_label :: #force_inline proc(self: ^ArgumentEncoder) -> ^NS.String { return msgSend(^NS.String, self, "label") } -@(objc_type=ArgumentEncoder, objc_name="newArgumentEncoderForBufferAtIndex") -ArgumentEncoder_newArgumentEncoderForBufferAtIndex :: #force_inline proc(self: ^ArgumentEncoder, index: NS.UInteger) -> ^ArgumentEncoder { +@(objc_type=ArgumentEncoder, objc_name="newArgumentEncoderForBuffer") +ArgumentEncoder_newArgumentEncoderForBuffer :: #force_inline proc(self: ^ArgumentEncoder, index: NS.UInteger) -> ^ArgumentEncoder { return msgSend(^ArgumentEncoder, self, "newArgumentEncoderForBufferAtIndex:", index) } @(objc_type=ArgumentEncoder, objc_name="setAccelerationStructure") @@ -5491,7 +5491,7 @@ Buffer_contents :: #force_inline proc(self: ^Buffer) -> []byte { } @(objc_type=Buffer, objc_name="contentsPointer") Buffer_contentsPointer :: #force_inline proc(self: ^Buffer) -> rawptr { - return msgSend([^]byte, self, "contents") + return msgSend(rawptr, self, "contents") } @(objc_type=Buffer, objc_name="didModifyRange") Buffer_didModifyRange :: #force_inline proc(self: ^Buffer, range: NS.Range) { @@ -5979,8 +5979,8 @@ ComputeCommandEncoder_setBuffers :: #force_inline proc(self: ^ComputeCommandEnco msgSend(nil, self, "setBuffers:offsets:withRange:", raw_data(buffers), raw_data(offsets), range) } @(objc_type=ComputeCommandEncoder, objc_name="setBytes") -ComputeCommandEncoder_setBytes :: #force_inline proc(self: ^ComputeCommandEncoder, bytes: rawptr, length: NS.UInteger, index: NS.UInteger) { - msgSend(nil, self, "setBytes:length:atIndex:", bytes, length, index) +ComputeCommandEncoder_setBytes :: #force_inline proc(self: ^ComputeCommandEncoder, bytes: []byte, index: NS.UInteger) { + msgSend(nil, self, "setBytes:length:atIndex:", raw_data(bytes), NS.UInteger(len(bytes)), index) } @(objc_type=ComputeCommandEncoder, objc_name="setComputePipelineState") ComputeCommandEncoder_setComputePipelineState :: #force_inline proc(self: ^ComputeCommandEncoder, pipelineState: ^ComputePipelineState) { @@ -5999,16 +5999,16 @@ ComputeCommandEncoder_setIntersectionFunctionTables :: #force_inline proc(self: assert(range.length <= NS.UInteger(len(intersectionFunctionTables))) msgSend(nil, self, "setIntersectionFunctionTables:withBufferRange:", raw_data(intersectionFunctionTables), range) } -@(objc_type=ComputeCommandEncoder, objc_name="setSamplerStateAtIndex") -ComputeCommandEncoder_setSamplerStateAtIndex :: #force_inline proc(self: ^ComputeCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { +@(objc_type=ComputeCommandEncoder, objc_name="setSamplerState") +ComputeCommandEncoder_setSamplerState :: #force_inline proc(self: ^ComputeCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { msgSend(nil, self, "setSamplerState:atIndex:", sampler, index) } -@(objc_type=ComputeCommandEncoder, objc_name="setSamplerState_lodMinClamp_lodMaxClampAtIndex") -ComputeCommandEncoder_setSamplerState_lodMinClamp_lodMaxClampAtIndex :: #force_inline proc(self: ^ComputeCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { +@(objc_type=ComputeCommandEncoder, objc_name="setSamplerState_lodMinClamp_lodMaxClamp") +ComputeCommandEncoder_setSamplerState_lodMinClamp_lodMaxClamp :: #force_inline proc(self: ^ComputeCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { msgSend(nil, self, "setSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } -@(objc_type=ComputeCommandEncoder, objc_name="setSamplerStates_lodMinClamps_lodMaxClampsWithRange") -ComputeCommandEncoder_setSamplerStates_lodMinClamps_lodMaxClampsWithRange :: #force_inline proc(self: ^ComputeCommandEncoder, samplers: []^SamplerState, lodMinClamps, lodMaxClamps: []f32, range: NS.Range) { +@(objc_type=ComputeCommandEncoder, objc_name="setSamplerStatesWithLod") +ComputeCommandEncoder_setSamplerStatesWithLod :: #force_inline proc(self: ^ComputeCommandEncoder, samplers: []^SamplerState, lodMinClamps, lodMaxClamps: []f32, range: NS.Range) { msgSend(nil, self, "setSamplerStates:lodMinClamps:lodMaxClamps:withRange:", raw_data(samplers), raw_data(lodMinClamps), raw_data(lodMaxClamps), range) } @(objc_type=ComputeCommandEncoder, objc_name="setSamplerStatesWithRange") @@ -6356,11 +6356,11 @@ Device_argumentBuffersSupport :: #force_inline proc(self: ^Device) -> ArgumentBu return msgSend(ArgumentBuffersTier, self, "argumentBuffersSupport") } @(objc_type=Device, objc_name="convertSparsePixelRegions") -Device_convertSparsePixelRegions :: #force_inline proc(self: ^Device, pixelRegions: ^Region, tileRegions: ^Region, tileSize: Size, mode: SparseTextureRegionAlignmentMode, numRegions: NS.UInteger) { +Device_convertSparsePixelRegions :: #force_inline proc(self: ^Device, pixelRegions, tileRegions: ^Region, tileSize: Size, mode: SparseTextureRegionAlignmentMode, numRegions: NS.UInteger) { msgSend(nil, self, "convertSparsePixelRegions:toTileRegions:withTileSize:alignmentMode:numRegions:", pixelRegions, tileRegions, tileSize, mode, numRegions) } @(objc_type=Device, objc_name="convertSparseTileRegions") -Device_convertSparseTileRegions :: #force_inline proc(self: ^Device, tileRegions: ^Region, pixelRegions: ^Region, tileSize: Size, numRegions: NS.UInteger) { +Device_convertSparseTileRegions :: #force_inline proc(self: ^Device, tileRegions, pixelRegions: ^Region, tileSize: Size, numRegions: NS.UInteger) { msgSend(nil, self, "convertSparseTileRegions:toPixelRegions:withTileSize:numRegions:", tileRegions, pixelRegions, tileSize, numRegions) } @(objc_type=Device, objc_name="counterSets") @@ -6372,20 +6372,22 @@ Device_currentAllocatedSize :: #force_inline proc(self: ^Device) -> NS.UInteger return msgSend(NS.UInteger, self, "currentAllocatedSize") } @(objc_type=Device, objc_name="getDefaultSamplePositions") -Device_getDefaultSamplePositions :: #force_inline proc(self: ^Device, positions: ^SamplePosition, count: NS.UInteger) { - msgSend(nil, self, "getDefaultSamplePositions:count:", positions, count) +Device_getDefaultSamplePositions :: #force_inline proc(self: ^Device, positions: []SamplePosition) { + msgSend(nil, self, "getDefaultSamplePositions:count:", raw_data(positions), NS.UInteger(len(positions))) } @(objc_type=Device, objc_name="hasUnifiedMemory") Device_hasUnifiedMemory :: #force_inline proc(self: ^Device) -> BOOL { return msgSend(BOOL, self, "hasUnifiedMemory") } @(objc_type=Device, objc_name="heapBufferSizeAndAlignWithLength") -Device_heapBufferSizeAndAlignWithLength :: #force_inline proc(self: ^Device, length: NS.UInteger, options: ResourceOptions) -> SizeAndAlign { - return msgSend(SizeAndAlign, self, "heapBufferSizeAndAlignWithLength:options:", length, options) +Device_heapBufferSizeAndAlignWithLength :: #force_inline proc(self: ^Device, length: NS.UInteger, options: ResourceOptions) -> (size, align: NS.UInteger) { + res := msgSend(SizeAndAlign, self, "heapBufferSizeAndAlignWithLength:options:", length, options) + return res.size, res.align } @(objc_type=Device, objc_name="heapTextureSizeAndAlignWithDescriptor") -Device_heapTextureSizeAndAlignWithDescriptor :: #force_inline proc(self: ^Device, desc: ^TextureDescriptor) -> SizeAndAlign { - return msgSend(SizeAndAlign, self, "heapTextureSizeAndAlignWithDescriptor:", desc) +Device_heapTextureSizeAndAlignWithDescriptor :: #force_inline proc(self: ^Device, desc: ^TextureDescriptor) -> (size, align: NS.UInteger) { + res := msgSend(SizeAndAlign, self, "heapTextureSizeAndAlignWithDescriptor:", desc) + return res.size, res.align } @(objc_type=Device, objc_name="isDepth24Stencil8PixelFormatSupported") Device_isDepth24Stencil8PixelFormatSupported :: #force_inline proc(self: ^Device) -> BOOL { @@ -6461,12 +6463,12 @@ Device_newBinaryArchiveWithDescriptor :: #force_inline proc(self: ^Device, descr return } @(objc_type=Device, objc_name="newBufferWithBytes") -Device_newBufferWithBytes :: #force_inline proc(self: ^Device, pointer: rawptr, length: NS.UInteger, options: ResourceOptions) -> ^Buffer { - return msgSend(^Buffer, self, "newBufferWithBytes:length:options:", pointer, length, options) +Device_newBufferWithBytes :: #force_inline proc(self: ^Device, bytes: []byte, options: ResourceOptions) -> ^Buffer { + return msgSend(^Buffer, self, "newBufferWithBytes:length:options:", raw_data(bytes), NS.UInteger(len(bytes)), options) } @(objc_type=Device, objc_name="newBufferWithBytesNoCopy") -Device_newBufferWithBytesNoCopy :: #force_inline proc(self: ^Device, pointer: rawptr, length: NS.UInteger, options: ResourceOptions, deallocator: rawptr) -> ^Buffer { - return msgSend(^Buffer, self, "newBufferWithBytesNoCopy:length:options:deallocator:", pointer, length, options, deallocator) +Device_newBufferWithBytesNoCopy :: #force_inline proc(self: ^Device, bytes: []byte, options: ResourceOptions, deallocator: rawptr) -> ^Buffer { + return msgSend(^Buffer, self, "newBufferWithBytesNoCopy:length:options:deallocator:", raw_data(bytes), NS.UInteger(len(bytes)), options, deallocator) } @(objc_type=Device, objc_name="newBufferWithLength") Device_newBufferWithLength :: #force_inline proc(self: ^Device, length: NS.UInteger, options: ResourceOptions) -> ^Buffer { @@ -7155,12 +7157,12 @@ Methods: @(objc_class="MTLIndirectCommandBuffer") IndirectCommandBuffer :: struct { using _: Resource } -@(objc_type=IndirectCommandBuffer, objc_name="indirectComputeCommandAtIndex") -IndirectCommandBuffer_indirectComputeCommandAtIndex :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: NS.UInteger) -> ^IndirectCommandBuffer { +@(objc_type=IndirectCommandBuffer, objc_name="indirectComputeCommand") +IndirectCommandBuffer_indirectComputeCommand :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: NS.UInteger) -> ^IndirectCommandBuffer { return msgSend(^IndirectCommandBuffer, self, "indirectComputeCommandAtIndex:", commandIndex) } -@(objc_type=IndirectCommandBuffer, objc_name="indirectRenderCommandAtIndex") -IndirectCommandBuffer_indirectRenderCommandAtIndex :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: NS.UInteger) -> ^IndirectCommandBuffer { +@(objc_type=IndirectCommandBuffer, objc_name="indirectRenderCommand") +IndirectCommandBuffer_indirectRenderCommand :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: NS.UInteger) -> ^IndirectCommandBuffer { return msgSend(^IndirectCommandBuffer, self, "indirectRenderCommandAtIndex:", commandIndex) } @(objc_type=IndirectCommandBuffer, objc_name="resetWithRange") @@ -7321,8 +7323,8 @@ IntersectionFunctionTable_setFunction :: #force_inline proc(self: ^IntersectionF IntersectionFunctionTable_setFunctions :: #force_inline proc(self: ^IntersectionFunctionTable, functions: []^FunctionHandle, range: NS.Range) { msgSend(nil, self, "setFunctions:withRange:", raw_data(functions), range) } -@(objc_type=IntersectionFunctionTable, objc_name="setOpaqueTriangleIntersectionFunctionWithSignatureAtIndex") -IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignatureAtIndex :: #force_inline proc(self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, index: NS.UInteger) { +@(objc_type=IntersectionFunctionTable, objc_name="setOpaqueTriangleIntersectionFunctionWithSignature") +IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignature :: #force_inline proc(self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, index: NS.UInteger) { msgSend(nil, self, "setOpaqueTriangleIntersectionFunctionWithSignature:atIndex:", signature, index) } @(objc_type=IntersectionFunctionTable, objc_name="setOpaqueTriangleIntersectionFunctionWithSignatureWithRange") @@ -7511,8 +7513,9 @@ RasterizationRateMap_mapScreenToPhysicalCoordinates :: #force_inline proc(self: return msgSend(Coordinate2D, self, "mapScreenToPhysicalCoordinates:forLayer:", screenCoordinates, layerIndex) } @(objc_type=RasterizationRateMap, objc_name="parameterBufferSizeAndAlign") -RasterizationRateMap_parameterBufferSizeAndAlign :: #force_inline proc(self: ^RasterizationRateMap) -> SizeAndAlign { - return msgSend(SizeAndAlign, self, "parameterBufferSizeAndAlign") +RasterizationRateMap_parameterBufferSizeAndAlign :: #force_inline proc(self: ^RasterizationRateMap) -> (size, align: NS.UInteger) { + res := msgSend(SizeAndAlign, self, "parameterBufferSizeAndAlign") + return res.size, res.align } @(objc_type=RasterizationRateMap, objc_name="physicalGranularity") RasterizationRateMap_physicalGranularity :: #force_inline proc(self: ^RasterizationRateMap) -> Size { @@ -7748,16 +7751,16 @@ RenderCommandEncoder_setFragmentBuffers :: #force_inline proc(self: ^RenderComma RenderCommandEncoder_setFragmentBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: []byte, index: NS.UInteger) { msgSend(nil, self, "setFragmentBytes:length:atIndex:", raw_data(bytes), NS.UInteger(len(bytes)), index) } -@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStateAtIndex") -RenderCommandEncoder_setFragmentSamplerStateAtIndex :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { +@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerState") +RenderCommandEncoder_setFragmentSamplerState :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { msgSend(nil, self, "setFragmentSamplerState:atIndex:", sampler, index) } -@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerState_lodMinClamp_lodMaxClampAtIndex") -RenderCommandEncoder_setFragmentSamplerState_lodMinClamp_lodMaxClampAtIndex :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { +@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStateWithLod") +RenderCommandEncoder_setFragmentSamplerStateWithLod :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { msgSend(nil, self, "setFragmentSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } -@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStates_lodMinClamps_lodMaxClampsWithRange") -RenderCommandEncoder_setFragmentSamplerStates_lodMinClamps_lodMaxClampsWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: []^SamplerState, lodMinClamps: []f32, lodMaxClamps: []f32, range: NS.Range) { +@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStatesWithLod") +RenderCommandEncoder_setFragmentSamplerStatesWithLod :: #force_inline proc(self: ^RenderCommandEncoder, samplers: []^SamplerState, lodMinClamps, lodMaxClamps: []f32, range: NS.Range) { msgSend(nil, self, "setFragmentSamplerStates:lodMinClamps:lodMaxClamps:withRange:", raw_data(samplers), raw_data(lodMinClamps), raw_data(lodMaxClamps), range) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStatesWithRange") @@ -7825,36 +7828,36 @@ RenderCommandEncoder_setTileBufferOffset :: #force_inline proc(self: ^RenderComm msgSend(nil, self, "setTileBufferOffset:atIndex:", offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setTileBuffers") -RenderCommandEncoder_setTileBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: [^]^Buffer, offsets: [^]NS.UInteger, range: NS.Range) { - msgSend(nil, self, "setTileBuffers:offsets:withRange:", buffers, offsets, range) +RenderCommandEncoder_setTileBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: []^Buffer, offsets: []NS.UInteger, range: NS.Range) { + msgSend(nil, self, "setTileBuffers:offsets:withRange:", raw_data(buffers), raw_data(offsets), range) } @(objc_type=RenderCommandEncoder, objc_name="setTileBytes") -RenderCommandEncoder_setTileBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: rawptr, length: NS.UInteger, index: NS.UInteger) { - msgSend(nil, self, "setTileBytes:length:atIndex:", bytes, length, index) +RenderCommandEncoder_setTileBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: []byte, index: NS.UInteger) { + msgSend(nil, self, "setTileBytes:length:atIndex:", raw_data(bytes), NS.UInteger(len(bytes)), index) } -@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerStateAtIndex") -RenderCommandEncoder_setTileSamplerStateAtIndex :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { +@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerState") +RenderCommandEncoder_setTileSamplerState :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { msgSend(nil, self, "setTileSamplerState:atIndex:", sampler, index) } -@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerState_lodMinClamp_lodMaxClampAtIndex") -RenderCommandEncoder_setTileSamplerState_lodMinClamp_lodMaxClampAtIndex :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { +@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerStateWithLod") +RenderCommandEncoder_setTileSamplerStateWithLod :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { msgSend(nil, self, "setTileSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } -@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerStates_lodMinClamps_lodMaxClampsWithRange") -RenderCommandEncoder_setTileSamplerStates_lodMinClamps_lodMaxClampsWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: [^]^SamplerState, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { - msgSend(nil, self, "setTileSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range) +@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerStatesWithLod") +RenderCommandEncoder_setTileSamplerStatesWithLod :: #force_inline proc(self: ^RenderCommandEncoder, samplers: []^SamplerState, lodMinClamps, lodMaxClamps: []f32, range: NS.Range) { + msgSend(nil, self, "setTileSamplerStates:lodMinClamps:lodMaxClamps:withRange:", raw_data(samplers), raw_data(lodMinClamps), raw_data(lodMaxClamps), range) } @(objc_type=RenderCommandEncoder, objc_name="setTileSamplerStatesWithRange") -RenderCommandEncoder_setTileSamplerStatesWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: [^]^SamplerState, range: NS.Range) { - msgSend(nil, self, "setTileSamplerStates:withRange:", samplers, range) +RenderCommandEncoder_setTileSamplerStatesWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: []^SamplerState, range: NS.Range) { + msgSend(nil, self, "setTileSamplerStates:withRange:", raw_data(samplers), range) } @(objc_type=RenderCommandEncoder, objc_name="setTileTexture") RenderCommandEncoder_setTileTexture :: #force_inline proc(self: ^RenderCommandEncoder, texture: ^Texture, index: NS.UInteger) { msgSend(nil, self, "setTileTexture:atIndex:", texture, index) } @(objc_type=RenderCommandEncoder, objc_name="setTileTextures") -RenderCommandEncoder_setTileTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: [^]^Texture, range: NS.Range) { - msgSend(nil, self, "setTileTextures:withRange:", textures, range) +RenderCommandEncoder_setTileTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: []^Texture, range: NS.Range) { + msgSend(nil, self, "setTileTextures:withRange:", raw_data(textures), range) } @(objc_type=RenderCommandEncoder, objc_name="setTriangleFillMode") RenderCommandEncoder_setTriangleFillMode :: #force_inline proc(self: ^RenderCommandEncoder, fillMode: TriangleFillMode) { @@ -7873,44 +7876,44 @@ RenderCommandEncoder_setVertexBufferOffset :: #force_inline proc(self: ^RenderCo msgSend(nil, self, "setVertexBufferOffset:atIndex:", offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setVertexBuffers") -RenderCommandEncoder_setVertexBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: [^]^Buffer, offsets: [^]NS.UInteger, range: NS.Range) { - msgSend(nil, self, "setVertexBuffers:offsets:withRange:", buffers, offsets, range) +RenderCommandEncoder_setVertexBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: []^Buffer, offsets: []NS.UInteger, range: NS.Range) { + msgSend(nil, self, "setVertexBuffers:offsets:withRange:", raw_data(buffers), raw_data(offsets), range) } @(objc_type=RenderCommandEncoder, objc_name="setVertexBytes") -RenderCommandEncoder_setVertexBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: rawptr, length: NS.UInteger, index: NS.UInteger) { - msgSend(nil, self, "setVertexBytes:length:atIndex:", bytes, length, index) +RenderCommandEncoder_setVertexBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: []byte, index: NS.UInteger) { + msgSend(nil, self, "setVertexBytes:length:atIndex:", raw_data(bytes), NS.UInteger(len(bytes)), index) } -@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerStateAtIndex") -RenderCommandEncoder_setVertexSamplerStateAtIndex :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { +@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerState") +RenderCommandEncoder_setVertexSamplerState :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { msgSend(nil, self, "setVertexSamplerState:atIndex:", sampler, index) } -@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerState_lodMinClamp_lodMaxClampAtIndex") -RenderCommandEncoder_setVertexSamplerState_lodMinClamp_lodMaxClampAtIndex :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { +@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerStateWithLod") +RenderCommandEncoder_setVertexSamplerStateWithLod :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { msgSend(nil, self, "setVertexSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } -@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerStates_lodMinClamps_lodMaxClampsWithRange") -RenderCommandEncoder_setVertexSamplerStates_lodMinClamps_lodMaxClampsWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: [^]^SamplerState, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) { - msgSend(nil, self, "setVertexSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range) +@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerStatesWithLod") +RenderCommandEncoder_setVertexSamplerStatesWithLod :: #force_inline proc(self: ^RenderCommandEncoder, samplers: []^SamplerState, lodMinClamps, lodMaxClamps: []f32, range: NS.Range) { + msgSend(nil, self, "setVertexSamplerStates:lodMinClamps:lodMaxClamps:withRange:", raw_data(samplers), raw_data(lodMinClamps), raw_data(lodMaxClamps), range) } @(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerStatesWithRange") -RenderCommandEncoder_setVertexSamplerStatesWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: [^]^SamplerState, range: NS.Range) { - msgSend(nil, self, "setVertexSamplerStates:withRange:", samplers, range) +RenderCommandEncoder_setVertexSamplerStatesWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: []^SamplerState, range: NS.Range) { + msgSend(nil, self, "setVertexSamplerStates:withRange:", raw_data(samplers), range) } @(objc_type=RenderCommandEncoder, objc_name="setVertexTexture") RenderCommandEncoder_setVertexTexture :: #force_inline proc(self: ^RenderCommandEncoder, texture: ^Texture, index: NS.UInteger) { msgSend(nil, self, "setVertexTexture:atIndex:", texture, index) } @(objc_type=RenderCommandEncoder, objc_name="setVertexTextures") -RenderCommandEncoder_setVertexTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: [^]^Texture, range: NS.Range) { - msgSend(nil, self, "setVertexTextures:withRange:", textures, range) +RenderCommandEncoder_setVertexTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: []^Texture, range: NS.Range) { + msgSend(nil, self, "setVertexTextures:withRange:", raw_data(textures), range) } @(objc_type=RenderCommandEncoder, objc_name="setViewport") RenderCommandEncoder_setViewport :: #force_inline proc(self: ^RenderCommandEncoder, viewport: Viewport) { msgSend(nil, self, "setViewport:", viewport) } @(objc_type=RenderCommandEncoder, objc_name="setViewports") -RenderCommandEncoder_setViewports :: #force_inline proc(self: ^RenderCommandEncoder, viewports: ^Viewport, count: NS.UInteger) { - msgSend(nil, self, "setViewports:count:", viewports, count) +RenderCommandEncoder_setViewports :: #force_inline proc(self: ^RenderCommandEncoder, viewports: []Viewport) { + msgSend(nil, self, "setViewports:count:", raw_data(viewports), NS.UInteger(len(viewports))) } @(objc_type=RenderCommandEncoder, objc_name="setVisibilityResultMode") RenderCommandEncoder_setVisibilityResultMode :: #force_inline proc(self: ^RenderCommandEncoder, mode: VisibilityResultMode, offset: NS.UInteger) { @@ -7941,12 +7944,12 @@ RenderCommandEncoder_useHeapWithStages :: #force_inline proc(self: ^RenderComman msgSend(nil, self, "useHeap:stages:", heap, stages) } @(objc_type=RenderCommandEncoder, objc_name="useHeaps") -RenderCommandEncoder_useHeaps :: #force_inline proc(self: ^RenderCommandEncoder, heaps: [^]^Heap, count: NS.UInteger) { - msgSend(nil, self, "useHeaps:count:", heaps, count) +RenderCommandEncoder_useHeaps :: #force_inline proc(self: ^RenderCommandEncoder, heaps: []^Heap) { + msgSend(nil, self, "useHeaps:count:", raw_data(heaps), NS.UInteger(len(heaps))) } @(objc_type=RenderCommandEncoder, objc_name="useHeapsWithStages") -RenderCommandEncoder_useHeapsWithStages :: #force_inline proc(self: ^RenderCommandEncoder, heaps: [^]^Heap, count: NS.UInteger, stages: RenderStages) { - msgSend(nil, self, "useHeaps:count:stages:", heaps, count, stages) +RenderCommandEncoder_useHeapsWithStages :: #force_inline proc(self: ^RenderCommandEncoder, heaps: []^Heap, stages: RenderStages) { + msgSend(nil, self, "useHeaps:count:stages:", raw_data(heaps), NS.UInteger(len(heaps)), stages) } @(objc_type=RenderCommandEncoder, objc_name="useResource") RenderCommandEncoder_useResource :: #force_inline proc(self: ^RenderCommandEncoder, resource: ^Resource, usage: ResourceUsage) { @@ -7957,12 +7960,12 @@ RenderCommandEncoder_useResourceWithStages :: #force_inline proc(self: ^RenderCo msgSend(nil, self, "useResource:usage:stages:", resource, usage, stages) } @(objc_type=RenderCommandEncoder, objc_name="useResources") -RenderCommandEncoder_useResources :: #force_inline proc(self: ^RenderCommandEncoder, resources: [^]^Resource, count: NS.UInteger, usage: ResourceUsage) { - msgSend(nil, self, "useResources:count:usage:", resources, count, usage) +RenderCommandEncoder_useResources :: #force_inline proc(self: ^RenderCommandEncoder, resources: []^Resource, usage: ResourceUsage) { + msgSend(nil, self, "useResources:count:usage:", raw_data(resources), NS.UInteger(len(resources)), usage) } @(objc_type=RenderCommandEncoder, objc_name="useResourcesStages") -RenderCommandEncoder_useResourcesStages :: #force_inline proc(self: ^RenderCommandEncoder, resources: [^]^Resource, count: NS.UInteger, usage: ResourceUsage, stages: RenderStages) { - msgSend(nil, self, "useResources:count:usage:stages:", resources, count, usage, stages) +RenderCommandEncoder_useResourcesStages :: #force_inline proc(self: ^RenderCommandEncoder, resources: []^Resource, usage: ResourceUsage, stages: RenderStages) { + msgSend(nil, self, "useResources:count:usage:stages:", raw_data(resources), NS.UInteger(len(resources)), usage, stages) } @(objc_type=RenderCommandEncoder, objc_name="waitForFence") RenderCommandEncoder_waitForFence :: #force_inline proc(self: ^RenderCommandEncoder, fence: ^Fence, stages: RenderStages) { @@ -8389,6 +8392,6 @@ VisibleFunctionTable_setFunction :: #force_inline proc(self: ^VisibleFunctionTab msgSend(nil, self, "setFunction:atIndex:", function, index) } @(objc_type=VisibleFunctionTable, objc_name="setFunctions") -VisibleFunctionTable_setFunctions :: #force_inline proc(self: ^VisibleFunctionTable, functions: [^]^FunctionHandle, range: NS.Range) { - msgSend(nil, self, "setFunctions:withRange:", functions, range) +VisibleFunctionTable_setFunctions :: #force_inline proc(self: ^VisibleFunctionTable, functions: []^FunctionHandle, range: NS.Range) { + msgSend(nil, self, "setFunctions:withRange:", raw_data(functions), range) } diff --git a/core/sys/darwin/Metal/MetalTypes.odin b/core/sys/darwin/Metal/MetalTypes.odin index e1269f926..4928847a9 100644 --- a/core/sys/darwin/Metal/MetalTypes.odin +++ b/core/sys/darwin/Metal/MetalTypes.odin @@ -147,8 +147,8 @@ Size :: struct { } SizeAndAlign :: struct { - size: NS.Integer, - align: NS.Integer, + size: NS.UInteger, + align: NS.UInteger, } StageInRegionIndirectArguments :: struct { From 4d0fd4cf1991f52db6e8586f2463470617982989 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 15:56:32 +0000 Subject: [PATCH 45/64] Correct `device()` usage --- core/sys/darwin/Metal/MetalClasses.odin | 48 ++++++++++++------------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 1f4ae50cb..8edb65694 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -4064,8 +4064,8 @@ SharedTextureHandle_init :: #force_inline proc(self: ^SharedTextureHandle) -> ^S return msgSend(^SharedTextureHandle, self, "init") } @(objc_type=SharedTextureHandle, objc_name="device") -SharedTextureHandle_device :: #force_inline proc(self: ^SharedTextureHandle) -> ^SharedTextureHandle { - return msgSend(^SharedTextureHandle, self, "device") +SharedTextureHandle_device :: #force_inline proc(self: ^SharedTextureHandle) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=SharedTextureHandle, objc_name="label") SharedTextureHandle_label :: #force_inline proc(self: ^SharedTextureHandle) -> ^NS.String { @@ -6169,8 +6169,8 @@ Methods: CounterSampleBuffer :: struct { using _: NS.Object } @(objc_type=CounterSampleBuffer, objc_name="device") -CounterSampleBuffer_device :: #force_inline proc(self: ^CounterSampleBuffer) -> ^CounterSampleBuffer { - return msgSend(^CounterSampleBuffer, self, "device") +CounterSampleBuffer_device :: #force_inline proc(self: ^CounterSampleBuffer) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=CounterSampleBuffer, objc_name="label") CounterSampleBuffer_label :: #force_inline proc(self: ^CounterSampleBuffer) -> ^NS.String { @@ -6792,8 +6792,8 @@ Methods: DynamicLibrary :: struct { using _: NS.Object } @(objc_type=DynamicLibrary, objc_name="device") -DynamicLibrary_device :: #force_inline proc(self: ^DynamicLibrary) -> ^DynamicLibrary { - return msgSend(^DynamicLibrary, self, "device") +DynamicLibrary_device :: #force_inline proc(self: ^DynamicLibrary) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=DynamicLibrary, objc_name="installName") DynamicLibrary_installName :: #force_inline proc(self: ^DynamicLibrary) -> ^NS.String { @@ -6828,8 +6828,8 @@ Methods: Event :: struct { using _: NS.Object } @(objc_type=Event, objc_name="device") -Event_device :: #force_inline proc(self: ^Event) -> ^Event { - return msgSend(^Event, self, "device") +Event_device :: #force_inline proc(self: ^Event) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=Event, objc_name="label") Event_label :: #force_inline proc(self: ^Event) -> ^NS.String { @@ -6855,8 +6855,8 @@ Methods: Fence :: struct { using _: NS.Object } @(objc_type=Fence, objc_name="device") -Fence_device :: #force_inline proc(self: ^Fence) -> ^Fence { - return msgSend(^Fence, self, "device") +Fence_device :: #force_inline proc(self: ^Fence) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=Fence, objc_name="label") Fence_label :: #force_inline proc(self: ^Fence) -> ^NS.String { @@ -6892,8 +6892,8 @@ Methods: Function :: struct { using _: NS.Object } @(objc_type=Function, objc_name="device") -Function_device :: #force_inline proc(self: ^Function) -> ^Function { - return msgSend(^Function, self, "device") +Function_device :: #force_inline proc(self: ^Function) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=Function, objc_name="functionConstantsDictionary") Function_functionConstantsDictionary :: #force_inline proc(self: ^Function) -> ^NS.Dictionary { @@ -6959,8 +6959,8 @@ Methods: FunctionHandle :: struct { using _: NS.Object } @(objc_type=FunctionHandle, objc_name="device") -FunctionHandle_device :: #force_inline proc(self: ^FunctionHandle) -> ^FunctionHandle { - return msgSend(^FunctionHandle, self, "device") +FunctionHandle_device :: #force_inline proc(self: ^FunctionHandle) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=FunctionHandle, objc_name="functionType") FunctionHandle_functionType :: #force_inline proc(self: ^FunctionHandle) -> FunctionType { @@ -7082,8 +7082,8 @@ Heap_currentAllocatedSize :: #force_inline proc(self: ^Heap) -> NS.UInteger { return msgSend(NS.UInteger, self, "currentAllocatedSize") } @(objc_type=Heap, objc_name="device") -Heap_device :: #force_inline proc(self: ^Heap) -> ^Heap { - return msgSend(^Heap, self, "device") +Heap_device :: #force_inline proc(self: ^Heap) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=Heap, objc_name="hazardTrackingMode") Heap_hazardTrackingMode :: #force_inline proc(self: ^Heap) -> HazardTrackingMode { @@ -7493,8 +7493,8 @@ RasterizationRateMap_copyParameterDataToBuffer :: #force_inline proc(self: ^Rast msgSend(nil, self, "copyParameterDataToBuffer:offset:", buffer, offset) } @(objc_type=RasterizationRateMap, objc_name="device") -RasterizationRateMap_device :: #force_inline proc(self: ^RasterizationRateMap) -> ^RasterizationRateMap { - return msgSend(^RasterizationRateMap, self, "device") +RasterizationRateMap_device :: #force_inline proc(self: ^RasterizationRateMap) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=RasterizationRateMap, objc_name="label") RasterizationRateMap_label :: #force_inline proc(self: ^RasterizationRateMap) -> ^NS.String { @@ -7991,8 +7991,8 @@ Methods: RenderPipelineState :: struct { using _: NS.Object } @(objc_type=RenderPipelineState, objc_name="device") -RenderPipelineState_device :: #force_inline proc(self: ^RenderPipelineState) -> ^RenderPipelineState { - return msgSend(^RenderPipelineState, self, "device") +RenderPipelineState_device :: #force_inline proc(self: ^RenderPipelineState) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=RenderPipelineState, objc_name="imageblockMemoryLengthForDimensions") RenderPipelineState_imageblockMemoryLengthForDimensions :: #force_inline proc(self: ^RenderPipelineState, imageblockDimensions: Size) -> ^RenderPipelineState { @@ -8052,8 +8052,8 @@ Resource_cpuCacheMode :: #force_inline proc(self: ^Resource) -> CPUCacheMode { return msgSend(CPUCacheMode, self, "cpuCacheMode") } @(objc_type=Resource, objc_name="device") -Resource_device :: #force_inline proc(self: ^Resource) -> ^Resource { - return msgSend(^Resource, self, "device") +Resource_device :: #force_inline proc(self: ^Resource) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=Resource, objc_name="hazardTrackingMode") Resource_hazardTrackingMode :: #force_inline proc(self: ^Resource) -> HazardTrackingMode { @@ -8147,8 +8147,8 @@ Methods: SamplerState :: struct { using _: NS.Object } @(objc_type=SamplerState, objc_name="device") -SamplerState_device :: #force_inline proc(self: ^SamplerState) -> ^SamplerState { - return msgSend(^SamplerState, self, "device") +SamplerState_device :: #force_inline proc(self: ^SamplerState) -> ^Device { + return msgSend(^Device, self, "device") } @(objc_type=SamplerState, objc_name="label") SamplerState_label :: #force_inline proc(self: ^SamplerState) -> ^NS.String { From 5212f62f54f5e7a88a6b7d5c40eed1761b526b52 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 16:18:23 +0000 Subject: [PATCH 46/64] Improve many methods with WithDescriptor suffixes --- core/sys/darwin/Metal/MetalClasses.odin | 118 ++++++++++++------------ 1 file changed, 60 insertions(+), 58 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 8edb65694..da1bffef4 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -4028,8 +4028,8 @@ SharedEventListener_alloc :: #force_inline proc() -> ^SharedEventListener { return msgSend(^SharedEventListener, SharedEventListener, "alloc") } @(objc_type=SharedEventListener, objc_name="dispatchQueue") -SharedEventListener_dispatchQueue :: #force_inline proc(self: ^SharedEventListener) -> NS.UInteger { - return msgSend(NS.UInteger, self, "dispatchQueue") +SharedEventListener_dispatchQueue :: #force_inline proc(self: ^SharedEventListener) -> dispatch_queue_t { + return msgSend(dispatch_queue_t, self, "dispatchQueue") } @(objc_type=SharedEventListener, objc_name="init") SharedEventListener_init :: #force_inline proc(self: ^SharedEventListener) -> ^SharedEventListener { @@ -5283,18 +5283,18 @@ Methods: @(objc_class="MTLBinaryArchive") BinaryArchive :: struct { using _: NS.Copying(BinaryArchive) } -@(objc_type=BinaryArchive, objc_name="addComputePipelineFunctionsWithDescriptor") -BinaryArchive_addComputePipelineFunctionsWithDescriptor :: #force_inline proc(self: ^BinaryArchive, descriptor: ^ComputePipelineDescriptor) -> (ok: BOOL, error: ^NS.Error) { +@(objc_type=BinaryArchive, objc_name="addComputePipelineFunctions") +BinaryArchive_addComputePipelineFunctions :: #force_inline proc(self: ^BinaryArchive, descriptor: ^ComputePipelineDescriptor) -> (ok: BOOL, error: ^NS.Error) { ok = msgSend(BOOL, self, "addComputePipelineFunctionsWithDescriptor:error:", descriptor, &error) return } -@(objc_type=BinaryArchive, objc_name="addRenderPipelineFunctionsWithDescriptor") -BinaryArchive_addRenderPipelineFunctionsWithDescriptor :: #force_inline proc(self: ^BinaryArchive, descriptor: ^RenderPipelineDescriptor) -> (ok: BOOL, error: ^NS.Error) { +@(objc_type=BinaryArchive, objc_name="addRenderPipelineFunctions") +BinaryArchive_addRenderPipelineFunctions :: #force_inline proc(self: ^BinaryArchive, descriptor: ^RenderPipelineDescriptor) -> (ok: BOOL, error: ^NS.Error) { ok = msgSend(BOOL, self, "addRenderPipelineFunctionsWithDescriptor:error:", descriptor, &error) return } -@(objc_type=BinaryArchive, objc_name="addTileRenderPipelineFunctionsWithDescriptor") -BinaryArchive_addTileRenderPipelineFunctionsWithDescriptor :: #force_inline proc(self: ^BinaryArchive, descriptor: ^TileRenderPipelineDescriptor) -> (ok: BOOL, error: ^NS.Error) { +@(objc_type=BinaryArchive, objc_name="addTileRenderPipelineFunctions") +BinaryArchive_addTileRenderPipelineFunctions :: #force_inline proc(self: ^BinaryArchive, descriptor: ^TileRenderPipelineDescriptor) -> (ok: BOOL, error: ^NS.Error) { ok = msgSend(BOOL, self, "addTileRenderPipelineFunctionsWithDescriptor:error:", descriptor, &error) return } @@ -5505,8 +5505,8 @@ Buffer_length :: #force_inline proc(self: ^Buffer) -> NS.UInteger { Buffer_newRemoteBufferViewForDevice :: #force_inline proc(self: ^Buffer, device: ^Device) -> ^Buffer { return msgSend(^Buffer, self, "newRemoteBufferViewForDevice:", device) } -@(objc_type=Buffer, objc_name="newTextureWithDescriptor") -Buffer_newTextureWithDescriptor :: #force_inline proc(self: ^Buffer, descriptor: ^TextureDescriptor, offset: NS.UInteger, bytesPerRow: NS.UInteger) -> ^Buffer { +@(objc_type=Buffer, objc_name="newTexture") +Buffer_newTexture :: #force_inline proc(self: ^Buffer, descriptor: ^TextureDescriptor, offset: NS.UInteger, bytesPerRow: NS.UInteger) -> ^Buffer { return msgSend(^Buffer, self, "newTextureWithDescriptor:offset:bytesPerRow:", descriptor, offset, bytesPerRow) } @(objc_type=Buffer, objc_name="remoteStorageBuffer") @@ -5518,11 +5518,6 @@ Buffer_removeAllDebugMarkers :: #force_inline proc(self: ^Buffer) { msgSend(nil, self, "removeAllDebugMarkers") } -@(objc_type=Buffer, objc_name="newTexture") -Buffer_newTexture :: #force_inline proc(self: ^Buffer, descriptor: ^TextureDescriptor, offset: NS.UInteger, bytesPerRow: NS.UInteger) -> ^Texture { - return msgSend(^Texture, self, "newTextureWithDescriptor:offset:bytesPerRow:") -} - //////////////////////////////////////////////////////////////////////////////// /* @@ -5700,8 +5695,8 @@ CommandBuffer_label :: #force_inline proc(self: ^CommandBuffer) -> ^NS.String { CommandBuffer_logs :: #force_inline proc(self: ^CommandBuffer) -> ^LogContainer { return msgSend(^LogContainer, self, "logs") } -@(objc_type=CommandBuffer, objc_name="parallelRenderCommandEncoderWithDescriptor") -CommandBuffer_parallelRenderCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, renderPassDescriptor: ^RenderPassDescriptor) -> ^ParallelRenderCommandEncoder { +@(objc_type=CommandBuffer, objc_name="parallelRenderCommandEncoder") +CommandBuffer_parallelRenderCommandEncoder :: #force_inline proc(self: ^CommandBuffer, renderPassDescriptor: ^RenderPassDescriptor) -> ^ParallelRenderCommandEncoder { return msgSend(^ParallelRenderCommandEncoder, self, "parallelRenderCommandEncoderWithDescriptor:", renderPassDescriptor) } @(objc_type=CommandBuffer, objc_name="popDebugGroup") @@ -6457,8 +6452,8 @@ Device_newAccelerationStructureWithSize :: #force_inline proc(self: ^Device, siz Device_newArgumentEncoderWithArguments :: #force_inline proc(self: ^Device, arguments: ^NS.Array) -> ^ArgumentEncoder { return msgSend(^ArgumentEncoder, self, "newArgumentEncoderWithArguments:", arguments) } -@(objc_type=Device, objc_name="newBinaryArchiveWithDescriptor") -Device_newBinaryArchiveWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^BinaryArchiveDescriptor) -> (res: ^BinaryArchive, error: ^NS.Error) { +@(objc_type=Device, objc_name="newBinaryArchive") +Device_newBinaryArchive :: #force_inline proc(self: ^Device, descriptor: ^BinaryArchiveDescriptor) -> (res: ^BinaryArchive, error: ^NS.Error) { res = msgSend(^BinaryArchive, self, "newBinaryArchiveWithDescriptor:error:", descriptor, &error) return } @@ -6470,8 +6465,8 @@ Device_newBufferWithBytes :: #force_inline proc(self: ^Device, bytes: []byte, op Device_newBufferWithBytesNoCopy :: #force_inline proc(self: ^Device, bytes: []byte, options: ResourceOptions, deallocator: rawptr) -> ^Buffer { return msgSend(^Buffer, self, "newBufferWithBytesNoCopy:length:options:deallocator:", raw_data(bytes), NS.UInteger(len(bytes)), options, deallocator) } -@(objc_type=Device, objc_name="newBufferWithLength") -Device_newBufferWithLength :: #force_inline proc(self: ^Device, length: NS.UInteger, options: ResourceOptions) -> ^Buffer { +@(objc_type=Device, objc_name="newBuffer") +Device_newBuffer :: #force_inline proc(self: ^Device, length: NS.UInteger, options: ResourceOptions) -> ^Buffer { return msgSend(^Buffer, self, "newBufferWithLength:options:", length, options) } @(objc_type=Device, objc_name="newCommandQueue") @@ -6509,8 +6504,8 @@ Device_newComputePipelineStateWithFunctionWithReflection :: #force_inline proc(s device = msgSend(^Device, self, "newComputePipelineStateWithFunction:options:reflection:error:", computeFunction, options, reflection, &error) return } -@(objc_type=Device, objc_name="newCounterSampleBufferWithDescriptor") -Device_newCounterSampleBufferWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^CounterSampleBufferDescriptor) -> (device: ^Device, error: ^NS.Error) { +@(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) return } @@ -6523,8 +6518,8 @@ Device_newDefaultLibraryWithBundle :: #force_inline proc(self: ^Device, bundle: library = msgSend(^Library, self, "newDefaultLibraryWithBundle:error:", bundle, &error) return } -@(objc_type=Device, objc_name="newDepthStencilStateWithDescriptor") -Device_newDepthStencilStateWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^DepthStencilDescriptor) -> ^DepthStencilState { +@(objc_type=Device, objc_name="newDepthStencilState") +Device_newDepthStencilState :: #force_inline proc(self: ^Device, descriptor: ^DepthStencilDescriptor) -> ^DepthStencilState { return msgSend(^DepthStencilState, self, "newDepthStencilStateWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newDynamicLibrary") @@ -6545,12 +6540,12 @@ Device_newEvent :: #force_inline proc(self: ^Device) -> ^Event { Device_newFence :: #force_inline proc(self: ^Device) -> ^Fence { return msgSend(^Fence, self, "newFence") } -@(objc_type=Device, objc_name="newHeapWithDescriptor") -Device_newHeapWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^HeapDescriptor) -> ^Heap { +@(objc_type=Device, objc_name="newHeap") +Device_newHeap :: #force_inline proc(self: ^Device, descriptor: ^HeapDescriptor) -> ^Heap { return msgSend(^Heap, self, "newHeapWithDescriptor:", descriptor) } -@(objc_type=Device, objc_name="newIndirectCommandBufferWithDescriptor") -Device_newIndirectCommandBufferWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^IndirectCommandBufferDescriptor, maxCount: NS.UInteger, options: ResourceOptions) -> ^IndirectCommandBuffer { +@(objc_type=Device, objc_name="newIndirectCommandBuffer") +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") @@ -6577,16 +6572,16 @@ Device_newLibraryWithURL :: #force_inline proc(self: ^Device, url: ^NS.URL) -> ( library = msgSend(^Library, self, "newLibraryWithURL:error:", url, &error) return } -@(objc_type=Device, objc_name="newRasterizationRateMapWithDescriptor") -Device_newRasterizationRateMapWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^RasterizationRateMapDescriptor) -> ^RasterizationRateMap { +@(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) { msgSend(nil, self, "newRenderPipelineStateWithDescriptor:completionHandler:", descriptor, completionHandler) } -@(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor") -Device_newRenderPipelineStateWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor) -> (pipeline: ^RenderPipelineState, error: ^NS.Error) { +@(objc_type=Device, objc_name="newRenderPipelineState") +Device_newRenderPipelineState :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor) -> (pipeline: ^RenderPipelineState, error: ^NS.Error) { pipeline = msgSend(^RenderPipelineState, self, "newRenderPipelineStateWithDescriptor:error:", descriptor, &error) return } @@ -6608,7 +6603,7 @@ Device_newRenderPipelineStateWithTileDescriptorWithReflection :: #force_inline p pipeline = msgSend(^RenderPipelineState, self, "newRenderPipelineStateWithTileDescriptor:options:reflection:error:", descriptor, options, reflection, &error) return } -@(objc_type=Device, objc_name="newSamplerStateWithDescriptor") +@(objc_type=Device, objc_name="newSamplerState") Device_newSamplerState :: #force_inline proc(self: ^Device, descriptor: ^SamplerDescriptor) -> ^SamplerState { return msgSend(^SamplerState, self, "newSamplerStateWithDescriptor:", descriptor) } @@ -6620,20 +6615,20 @@ 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="newSharedTextureWithDescriptor") -Device_newSharedTextureWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^TextureDescriptor) -> ^SharedEvent { +@(objc_type=Device, objc_name="newSharedTexture") +Device_newSharedTexture :: #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="newTextureWithDescriptor") -Device_newTextureWithDescriptor :: #force_inline proc(self: ^Device, desc: ^TextureDescriptor) -> ^SharedEvent { +@(objc_type=Device, objc_name="newTexture") +Device_newTexture :: #force_inline proc(self: ^Device, desc: ^TextureDescriptor) -> ^SharedEvent { return msgSend(^SharedEvent, self, "newTextureWithDescriptor:", desc) } -@(objc_type=Device, objc_name="newTextureWithDescriptorWithIOSurface") -Device_newTextureWithDescriptorWithIOSurface :: #force_inline proc(self: ^Device, descriptor: ^TextureDescriptor, iosurface: IOSurfaceRef, plane: NS.UInteger) -> ^Texture { +@(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="peerCount") @@ -7097,20 +7092,20 @@ Heap_label :: #force_inline proc(self: ^Heap) -> ^NS.String { Heap_maxAvailableSizeWithAlignment :: #force_inline proc(self: ^Heap, alignment: NS.UInteger) -> ^Heap { return msgSend(^Heap, self, "maxAvailableSizeWithAlignment:", alignment) } -@(objc_type=Heap, objc_name="newBufferWithLength") -Heap_newBufferWithLength :: #force_inline proc(self: ^Heap, length: NS.UInteger, options: ResourceOptions) -> ^Heap { +@(objc_type=Heap, objc_name="newBuffer") +Heap_newBuffer :: #force_inline proc(self: ^Heap, length: NS.UInteger, options: ResourceOptions) -> ^Heap { return msgSend(^Heap, self, "newBufferWithLength:options:", length, options) } -@(objc_type=Heap, objc_name="newBufferWithLengthWithOptions") -Heap_newBufferWithLengthWithOptions :: #force_inline proc(self: ^Heap, length: NS.UInteger, options: ResourceOptions, offset: NS.UInteger) -> ^Heap { +@(objc_type=Heap, objc_name="newBufferWithOptions") +Heap_newBufferWithOptions :: #force_inline proc(self: ^Heap, length: NS.UInteger, options: ResourceOptions, offset: NS.UInteger) -> ^Heap { return msgSend(^Heap, self, "newBufferWithLength:options:offset:", length, options, offset) } -@(objc_type=Heap, objc_name="newTextureWithDescriptor") -Heap_newTextureWithDescriptor :: #force_inline proc(self: ^Heap, desc: ^TextureDescriptor) -> ^Heap { +@(objc_type=Heap, objc_name="newTexture") +Heap_newTexture :: #force_inline proc(self: ^Heap, desc: ^TextureDescriptor) -> ^Heap { return msgSend(^Heap, self, "newTextureWithDescriptor:", desc) } -@(objc_type=Heap, objc_name="newTextureWithDescriptorWithOffset") -Heap_newTextureWithDescriptorWithOffset :: #force_inline proc(self: ^Heap, descriptor: ^TextureDescriptor, offset: NS.UInteger) -> ^Heap { +@(objc_type=Heap, objc_name="newTextureWithOffset") +Heap_newTextureWithOffset :: #force_inline proc(self: ^Heap, descriptor: ^TextureDescriptor, offset: NS.UInteger) -> ^Heap { return msgSend(^Heap, self, "newTextureWithDescriptor:offset:", descriptor, offset) } @(objc_type=Heap, objc_name="resourceOptions") @@ -7380,8 +7375,8 @@ Library_installName :: #force_inline proc(self: ^Library) -> ^NS.String { Library_label :: #force_inline proc(self: ^Library) -> ^NS.String { return msgSend(^NS.String, self, "label") } -@(objc_type=Library, objc_name="newFunctionWithDescriptorWithCompletionHandler") -Library_newFunctionWithDescriptorWithCompletionHandler :: #force_inline proc(self: ^Library, descriptor: ^FunctionDescriptor, completionHandler: rawptr) -> ^Function { +@(objc_type=Library, objc_name="newFunctionWithCompletionHandler") +Library_newFunctionWithCompletionHandler :: #force_inline proc(self: ^Library, descriptor: ^FunctionDescriptor, completionHandler: rawptr) -> ^Function { return msgSend(^Function, self, "newFunctionWithDescriptor:completionHandler:", descriptor, completionHandler) } @(objc_type=Library, objc_name="newFunctionWithDescriptor") @@ -7393,21 +7388,21 @@ Library_newFunctionWithDescriptor :: #force_inline proc(self: ^Library, descript Library_newFunctionWithName :: #force_inline proc(self: ^Library, functionName: ^NS.String) -> ^Function { return msgSend(^Function, self, "newFunctionWithName:", functionName) } -@(objc_type=Library, objc_name="newFunctionWithNameWithConstantValuesAndCompletionHandler") -Library_newFunctionWithNameWithConstantValuesAndCompletionHandler :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues, completionHandler: rawptr) -> ^Function { +@(objc_type=Library, objc_name="newFunctionWithConstantValuesAndCompletionHandler") +Library_newFunctionWithConstantValuesAndCompletionHandler :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues, completionHandler: rawptr) -> ^Function { return msgSend(^Function, self, "newFunctionWithName:constantValues:completionHandler:", name, constantValues, completionHandler) } -@(objc_type=Library, objc_name="newFunctionWithNameWithConstantValues") -Library_newFunctionWithNameWithConstantValues :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues) -> (function: ^Function, error: ^NS.Error) { +@(objc_type=Library, objc_name="newFunctionWithConstantValues") +Library_newFunctionWithConstantValues :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues) -> (function: ^Function, error: ^NS.Error) { function = msgSend(^Function, self, "newFunctionWithName:constantValues:error:", name, constantValues, &error) return } -@(objc_type=Library, objc_name="newIntersectionFunctionWithDescriptorWithCompletionHandler") -Library_newIntersectionFunctionWithDescriptorWithCompletionHandler :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor, completionHandler: rawptr) -> ^Function { +@(objc_type=Library, objc_name="newIntersectionFunctionWithCompletionHandler") +Library_newIntersectionFunctionWithCompletionHandler :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor, completionHandler: rawptr) -> ^Function { return msgSend(^Function, self, "newIntersectionFunctionWithDescriptor:completionHandler:", descriptor, completionHandler) } -@(objc_type=Library, objc_name="newIntersectionFunctionWithDescriptor") -Library_newIntersectionFunctionWithDescriptor :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor) -> (function: ^Function, error: ^NS.Error) { +@(objc_type=Library, objc_name="newIntersectionFunction") +Library_newIntersectionFunction :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor) -> (function: ^Function, error: ^NS.Error) { function = msgSend(^Function, self, "newIntersectionFunctionWithDescriptor:error:", descriptor, &error) return } @@ -8395,3 +8390,10 @@ VisibleFunctionTable_setFunction :: #force_inline proc(self: ^VisibleFunctionTab VisibleFunctionTable_setFunctions :: #force_inline proc(self: ^VisibleFunctionTable, functions: []^FunctionHandle, range: NS.Range) { msgSend(nil, self, "setFunctions:withRange:", raw_data(functions), range) } + + + +// TODO: Entire FunctionStitching API (which appears not to be in been missed from the generator) + + + From 83d63e572a94566de21dbe49b8e29543e69853e6 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 16:21:00 +0000 Subject: [PATCH 47/64] Improve indirect stuff --- core/sys/darwin/Metal/MetalClasses.odin | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index da1bffef4..b4625eb51 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -7153,12 +7153,12 @@ Methods: IndirectCommandBuffer :: struct { using _: Resource } @(objc_type=IndirectCommandBuffer, objc_name="indirectComputeCommand") -IndirectCommandBuffer_indirectComputeCommand :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: NS.UInteger) -> ^IndirectCommandBuffer { - return msgSend(^IndirectCommandBuffer, self, "indirectComputeCommandAtIndex:", commandIndex) +IndirectCommandBuffer_indirectComputeCommand :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: NS.UInteger) -> ^IndirectComputeBuffer { + return msgSend(^IndirectComputeBuffer, self, "indirectComputeCommandAtIndex:", commandIndex) } @(objc_type=IndirectCommandBuffer, objc_name="indirectRenderCommand") -IndirectCommandBuffer_indirectRenderCommand :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: NS.UInteger) -> ^IndirectCommandBuffer { - return msgSend(^IndirectCommandBuffer, self, "indirectRenderCommandAtIndex:", commandIndex) +IndirectCommandBuffer_indirectRenderCommand :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: NS.UInteger) -> ^IndirectRenderBuffer { + return msgSend(^IndirectRenderBuffer, self, "indirectRenderCommandAtIndex:", commandIndex) } @(objc_type=IndirectCommandBuffer, objc_name="resetWithRange") IndirectCommandBuffer_resetWithRange :: #force_inline proc(self: ^IndirectCommandBuffer, range: NS.Range) { @@ -7251,7 +7251,7 @@ Methods: IndirectRenderCommand :: struct { using _: NS.Object } @(objc_type=IndirectRenderCommand, objc_name="drawIndexedPatches") -IndirectRenderCommand_drawIndexedPatches :: #force_inline proc(self: ^IndirectRenderCommand, numberOfPatchControlPoints: NS.UInteger, patchStart: NS.UInteger, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, controlPointIndexBuffer: ^Buffer, controlPointIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger, buffer: ^Buffer, offset: NS.UInteger, instanceStride: NS.UInteger) { +IndirectRenderCommand_drawIndexedPatches :: #force_inline proc(self: ^IndirectRenderCommand, numberOfPatchControlPoints: NS.UInteger, patchStart, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, controlPointIndexBuffer: ^Buffer, controlPointIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger, buffer: ^Buffer, offset: NS.UInteger, instanceStride: NS.UInteger) { msgSend(nil, self, "drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride) } @(objc_type=IndirectRenderCommand, objc_name="drawIndexedPrimitives") @@ -7259,7 +7259,7 @@ IndirectRenderCommand_drawIndexedPrimitives :: #force_inline proc(self: ^Indirec msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount, baseVertex, baseInstance) } @(objc_type=IndirectRenderCommand, objc_name="drawPatches") -IndirectRenderCommand_drawPatches :: #force_inline proc(self: ^IndirectRenderCommand, numberOfPatchControlPoints: NS.UInteger, patchStart: NS.UInteger, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger, buffer: ^Buffer, offset: NS.UInteger, instanceStride: NS.UInteger) { +IndirectRenderCommand_drawPatches :: #force_inline proc(self: ^IndirectRenderCommand, numberOfPatchControlPoints: NS.UInteger, patchStart, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger, buffer: ^Buffer, offset: NS.UInteger, instanceStride: NS.UInteger) { msgSend(nil, self, "drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride) } @(objc_type=IndirectRenderCommand, objc_name="drawPrimitives") @@ -7631,7 +7631,7 @@ RenderCommandEncoder_drawIndexedPatches_patchIndexBuffer_patchIndexBufferOffset_ msgSend(nil, self, "drawIndexedPatches:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:indirectBuffer:indirectBufferOffset:", numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, indirectBuffer, indirectBufferOffset) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_") -RenderCommandEncoder_drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchStart: NS.UInteger, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, controlPointIndexBuffer: ^Buffer, controlPointIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) { +RenderCommandEncoder_drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchStart, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, controlPointIndexBuffer: ^Buffer, controlPointIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) { msgSend(nil, self, "drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, instanceCount, baseInstance) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_") @@ -7655,7 +7655,7 @@ RenderCommandEncoder_drawPatches_patchIndexBuffer_patchIndexBufferOffset_indirec msgSend(nil, self, "drawPatches:patchIndexBuffer:patchIndexBufferOffset:indirectBuffer:indirectBufferOffset:", numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, indirectBuffer, indirectBufferOffset) } @(objc_type=RenderCommandEncoder, objc_name="drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_") -RenderCommandEncoder_drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchStart: NS.UInteger, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) { +RenderCommandEncoder_drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchStart, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) { msgSend(nil, self, "drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance) } @(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_indirectBuffer_indirectBufferOffset_") From b755609438816381accefec8c208d8a2d4690ed4 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 16:25:20 +0000 Subject: [PATCH 48/64] Improve Library related stuff --- core/sys/darwin/Metal/MetalClasses.odin | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index b4625eb51..e5a4b7508 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -6906,13 +6906,13 @@ Function_label :: #force_inline proc(self: ^Function) -> ^NS.String { Function_name :: #force_inline proc(self: ^Function) -> ^NS.String { return msgSend(^NS.String, self, "name") } -@(objc_type=Function, objc_name="newArgumentEncoderWithBufferIndex") -Function_newArgumentEncoderWithBufferIndex :: #force_inline proc(self: ^Function, bufferIndex: NS.UInteger) -> ^Function { - return msgSend(^Function, self, "newArgumentEncoderWithBufferIndex:", bufferIndex) +@(objc_type=Function, objc_name="newArgumentEncoder") +Function_newArgumentEncoder :: #force_inline proc(self: ^Function, bufferIndex: NS.UInteger) -> ^ArgumentEncoder { + return msgSend(^ArgumentEncoder, self, "newArgumentEncoderWithBufferIndex:", bufferIndex) } -@(objc_type=Function, objc_name="newArgumentEncoderWithBufferIndexWithReflection") -Function_newArgumentEncoderWithBufferIndexWithReflection :: #force_inline proc(self: ^Function, bufferIndex: NS.UInteger, reflection: ^AutoreleasedArgument) -> ^Function { - return msgSend(^Function, self, "newArgumentEncoderWithBufferIndex:reflection:", bufferIndex, reflection) +@(objc_type=Function, objc_name="newArgumentEncoderWithReflection") +Function_newArgumentEncoderWithReflection :: #force_inline proc(self: ^Function, bufferIndex: NS.UInteger, reflection: ^AutoreleasedArgument) -> ^ArgumentEncoder { + return msgSend(^ArgumentEncoder, self, "newArgumentEncoderWithBufferIndex:reflection:", bufferIndex, reflection) } @(objc_type=Function, objc_name="options") Function_options :: #force_inline proc(self: ^Function) -> FunctionOptions { From 934e66ab3bb34cdbb9e1a011531d13e9a691c37a Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 16:26:42 +0000 Subject: [PATCH 49/64] More improvements --- core/sys/darwin/Metal/MetalClasses.odin | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index e5a4b7508..0eb5c42cf 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -7434,8 +7434,8 @@ Methods: ParallelRenderCommandEncoder :: struct { using _: CommandEncoder } @(objc_type=ParallelRenderCommandEncoder, objc_name="renderCommandEncoder") -ParallelRenderCommandEncoder_renderCommandEncoder :: #force_inline proc(self: ^ParallelRenderCommandEncoder) -> ^ParallelRenderCommandEncoder { - return msgSend(^ParallelRenderCommandEncoder, self, "renderCommandEncoder") +ParallelRenderCommandEncoder_renderCommandEncoder :: #force_inline proc(self: ^ParallelRenderCommandEncoder) -> ^RenderCommandEncoder { + return msgSend(^RenderCommandEncoder, self, "renderCommandEncoder") } @(objc_type=ParallelRenderCommandEncoder, objc_name="setColorStoreAction") ParallelRenderCommandEncoder_setColorStoreAction :: #force_inline proc(self: ^ParallelRenderCommandEncoder, storeAction: StoreAction, colorAttachmentIndex: NS.UInteger) { From 4cc597f4df826ac249ce74ec0d188cc3441acdb8 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 16:32:54 +0000 Subject: [PATCH 50/64] RasterizationRate improvements --- core/sys/darwin/Metal/MetalClasses.odin | 26 ++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 0eb5c42cf..07dce72b0 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -2562,8 +2562,8 @@ RasterizationRateLayerDescriptor_horizontal :: #force_inline proc(self: ^Rasteri return msgSend(^RasterizationRateSampleArray, self, "horizontal") } @(objc_type=RasterizationRateLayerDescriptor, objc_name="horizontalSampleStorage") -RasterizationRateLayerDescriptor_horizontalSampleStorage :: #force_inline proc(self: ^RasterizationRateLayerDescriptor) -> ^f32 { - return msgSend(^f32, self, "horizontalSampleStorage") +RasterizationRateLayerDescriptor_horizontalSampleStorage :: #force_inline proc(self: ^RasterizationRateLayerDescriptor) -> [^]f32 { // TODO: how could this be made into a slice? + return msgSend([^]f32, self, "horizontalSampleStorage") } @(objc_type=RasterizationRateLayerDescriptor, objc_name="init") RasterizationRateLayerDescriptor_init :: #force_inline proc(self: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateLayerDescriptor { @@ -2574,8 +2574,8 @@ RasterizationRateLayerDescriptor_initWithSampleCount :: #force_inline proc(self: return msgSend(^RasterizationRateLayerDescriptor, self, "initWithSampleCount:", sampleCount) } @(objc_type=RasterizationRateLayerDescriptor, objc_name="initWithSampleCountWithDimensions") -RasterizationRateLayerDescriptor_initWithSampleCountWithDimensions :: #force_inline proc(self: ^RasterizationRateLayerDescriptor, sampleCount: Size, horizontal: ^f32, vertical: ^f32) -> ^RasterizationRateLayerDescriptor { - return msgSend(^RasterizationRateLayerDescriptor, self, "initWithSampleCount:horizontal:vertical:", sampleCount, horizontal, vertical) +RasterizationRateLayerDescriptor_initWithSampleCountWithDimensions :: #force_inline proc(self: ^RasterizationRateLayerDescriptor, sampleCount: Size, horizontal: []f32, vertical: []f32) -> ^RasterizationRateLayerDescriptor { + return msgSend(^RasterizationRateLayerDescriptor, self, "initWithSampleCount:horizontal:vertical:", sampleCount, raw_data(horizontal), raw_data(vertical)) } @(objc_type=RasterizationRateLayerDescriptor, objc_name="sampleCount") RasterizationRateLayerDescriptor_sampleCount :: #force_inline proc(self: ^RasterizationRateLayerDescriptor) -> Size { @@ -2586,8 +2586,8 @@ RasterizationRateLayerDescriptor_vertical :: #force_inline proc(self: ^Rasteriza return msgSend(^RasterizationRateSampleArray, self, "vertical") } @(objc_type=RasterizationRateLayerDescriptor, objc_name="verticalSampleStorage") -RasterizationRateLayerDescriptor_verticalSampleStorage :: #force_inline proc(self: ^RasterizationRateLayerDescriptor) -> ^f32 { - return msgSend(^f32, self, "verticalSampleStorage") +RasterizationRateLayerDescriptor_verticalSampleStorage :: #force_inline proc(self: ^RasterizationRateLayerDescriptor) -> [^]f32 { // TODO: how could this be made into a slice? + return msgSend([^]f32, self, "verticalSampleStorage") } //////////////////////////////////////////////////////////////////////////////// @@ -2691,11 +2691,11 @@ RasterizationRateSampleArray_init :: #force_inline proc(self: ^RasterizationRate return msgSend(^RasterizationRateSampleArray, self, "init") } @(objc_type=RasterizationRateSampleArray, objc_name="object") -RasterizationRateSampleArray_object :: #force_inline proc(self: ^RasterizationRateSampleArray, index: NS.UInteger) -> NS.UInteger { - return msgSend(NS.UInteger, self, "objectAtIndexedSubscript:", index) +RasterizationRateSampleArray_object :: #force_inline proc(self: ^RasterizationRateSampleArray, index: NS.UInteger) -> ^NS.Number { + return msgSend(^NS.Number, self, "objectAtIndexedSubscript:", index) } @(objc_type=RasterizationRateSampleArray, objc_name="setObject") -RasterizationRateSampleArray_setObject :: #force_inline proc(self: ^RasterizationRateSampleArray, value: NS.UInteger, index: NS.UInteger) { +RasterizationRateSampleArray_setObject :: #force_inline proc(self: ^RasterizationRateSampleArray, value: ^NS.Number, index: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", value, index) } @@ -7153,12 +7153,12 @@ Methods: IndirectCommandBuffer :: struct { using _: Resource } @(objc_type=IndirectCommandBuffer, objc_name="indirectComputeCommand") -IndirectCommandBuffer_indirectComputeCommand :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: NS.UInteger) -> ^IndirectComputeBuffer { - return msgSend(^IndirectComputeBuffer, self, "indirectComputeCommandAtIndex:", commandIndex) +IndirectCommandBuffer_indirectComputeCommand :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: NS.UInteger) -> ^IndirectComputeCommand { + return msgSend(^IndirectComputeCommand, self, "indirectComputeCommandAtIndex:", commandIndex) } @(objc_type=IndirectCommandBuffer, objc_name="indirectRenderCommand") -IndirectCommandBuffer_indirectRenderCommand :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: NS.UInteger) -> ^IndirectRenderBuffer { - return msgSend(^IndirectRenderBuffer, self, "indirectRenderCommandAtIndex:", commandIndex) +IndirectCommandBuffer_indirectRenderCommand :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: NS.UInteger) -> ^IndirectRenderCommand { + return msgSend(^IndirectRenderCommand, self, "indirectRenderCommandAtIndex:", commandIndex) } @(objc_type=IndirectCommandBuffer, objc_name="resetWithRange") IndirectCommandBuffer_resetWithRange :: #force_inline proc(self: ^IndirectCommandBuffer, range: NS.Range) { From 7b42cbea209b4481e4ce10775485e6dea63ee7f8 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 16:42:53 +0000 Subject: [PATCH 51/64] Improve draw method names on RenderCommandEncoder --- core/sys/darwin/Metal/MetalClasses.odin | 48 ++++++++++++------------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 07dce72b0..4a1aeb55f 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -7626,52 +7626,52 @@ RenderCommandEncoder :: struct { using _: CommandEncoder } RenderCommandEncoder_dispatchThreadsPerTile :: #force_inline proc(self: ^RenderCommandEncoder, threadsPerTile: Size) { msgSend(nil, self, "dispatchThreadsPerTile:", threadsPerTile) } -@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPatches_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_indirectBuffer_indirectBufferOffset_") -RenderCommandEncoder_drawIndexedPatches_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, controlPointIndexBuffer: ^Buffer, controlPointIndexBufferOffset: NS.UInteger, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { +@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPatchesWihtIndirect") +RenderCommandEncoder_drawIndexedPatchesWihtIndirect :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, controlPointIndexBuffer: ^Buffer, controlPointIndexBufferOffset: NS.UInteger, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "drawIndexedPatches:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:indirectBuffer:indirectBufferOffset:", numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, indirectBuffer, indirectBufferOffset) } -@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_") -RenderCommandEncoder_drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchStart, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, controlPointIndexBuffer: ^Buffer, controlPointIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) { +@(objc_type=RenderCommandEncoder, objc_name="drawIndexPatchesWithInstances") +RenderCommandEncoder_drawIndexPatchesWithInstance :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchStart, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, controlPointIndexBuffer: ^Buffer, controlPointIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) { msgSend(nil, self, "drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, instanceCount, baseInstance) } -@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_") -RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: NS.UInteger, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger) { +@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives") +RenderCommandEncoder_drawIndexedPrimitives :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: NS.UInteger, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger) { msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset) } -@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_") -RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: NS.UInteger, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger, instanceCount: NS.UInteger) { +@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitivesWithInstanceCount") +RenderCommandEncoder_drawIndexedPrimitivesWithInstanceCount :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: NS.UInteger, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger, instanceCount: NS.UInteger) { msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount) } -@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_") -RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: NS.UInteger, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseVertex: NS.Integer, baseInstance: NS.UInteger) { +@(objc_type=RenderCommandEncoder, objc_name="drawIndexPrimitivesWithBaseVertex") +RenderCommandEncoder_drawIndexPrimitivesWithBaseVertex :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: NS.UInteger, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseVertex: NS.Integer, baseInstance: NS.UInteger) { msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount, baseVertex, baseInstance) } -@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexType_indexBuffer_indexBufferOffset_indirectBuffer_indirectBufferOffset_") -RenderCommandEncoder_drawIndexedPrimitives_indexType_indexBuffer_indexBufferOffset_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { +@(objc_type=RenderCommandEncoder, objc_name="drawIndexPrimitivesWithIndirect") +RenderCommandEncoder_drawIndexPrimitivesWithIndirect :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "drawIndexedPrimitives:indexType:indexBuffer:indexBufferOffset:indirectBuffer:indirectBufferOffset:", primitiveType, indexType, indexBuffer, indexBufferOffset, indirectBuffer, indirectBufferOffset) } -@(objc_type=RenderCommandEncoder, objc_name="drawPatches_patchIndexBuffer_patchIndexBufferOffset_indirectBuffer_indirectBufferOffset_") -RenderCommandEncoder_drawPatches_patchIndexBuffer_patchIndexBufferOffset_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { +@(objc_type=RenderCommandEncoder, objc_name="drawPatches") +RenderCommandEncoder_drawPatches :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "drawPatches:patchIndexBuffer:patchIndexBufferOffset:indirectBuffer:indirectBufferOffset:", numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, indirectBuffer, indirectBufferOffset) } -@(objc_type=RenderCommandEncoder, objc_name="drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_") -RenderCommandEncoder_drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_ :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchStart, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) { +@(objc_type=RenderCommandEncoder, objc_name="drawPatchesWithInstances") +RenderCommandEncoder_drawPatchesWithInstance :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchStart, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) { msgSend(nil, self, "drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance) } -@(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_indirectBuffer_indirectBufferOffset_") -RenderCommandEncoder_drawPrimitives_indirectBuffer_indirectBufferOffset_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { +@(objc_type=RenderCommandEncoder, objc_name="drawPrimitivesWithIndirect") +RenderCommandEncoder_drawPrimitivesWithIndirect :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "drawPrimitives:indirectBuffer:indirectBufferOffset:", primitiveType, indirectBuffer, indirectBufferOffset) } -@(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_vertexStart_vertexCount_") -RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger) { +@(objc_type=RenderCommandEncoder, objc_name="drawPrimitives") +RenderCommandEncoder_drawPrimitives :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger) { msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:", primitiveType, vertexStart, vertexCount) } -@(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_vertexStart_vertexCount_instanceCount_") -RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_instanceCount_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger, instanceCount: NS.UInteger) { +@(objc_type=RenderCommandEncoder, objc_name="drawPrimitivesWithInstanceCount") +RenderCommandEncoder_drawPrimitivesWithInstanceCount :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger, instanceCount: NS.UInteger) { msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:instanceCount:", primitiveType, vertexStart, vertexCount, instanceCount) } -@(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_") -RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_ :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) { +@(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) { msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:", primitiveType, vertexStart, vertexCount, instanceCount, baseInstance) } @(objc_type=RenderCommandEncoder, objc_name="executeCommandsInBuffer") From 60f4d8f1ec47a47c26693656fa417ed08a8427c9 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 16:46:27 +0000 Subject: [PATCH 52/64] Correct Render Pass types --- core/sys/darwin/Metal/MetalClasses.odin | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 4a1aeb55f..1ad39e925 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -2767,8 +2767,8 @@ RenderPassAttachmentDescriptor_resolveSlice :: #force_inline proc(self: ^RenderP return msgSend(NS.UInteger, self, "resolveSlice") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveTexture") -RenderPassAttachmentDescriptor_resolveTexture :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> ^RenderPassAttachmentDescriptor { - return msgSend(^RenderPassAttachmentDescriptor, self, "resolveTexture") +RenderPassAttachmentDescriptor_resolveTexture :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> ^Texture { + return msgSend(^Texture, self, "resolveTexture") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setDepthPlane") RenderPassAttachmentDescriptor_setDepthPlane :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, depthPlane: NS.UInteger) { @@ -2827,8 +2827,8 @@ RenderPassAttachmentDescriptor_storeActionOptions :: #force_inline proc(self: ^R return msgSend(StoreActionOptions, self, "storeActionOptions") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="texture") -RenderPassAttachmentDescriptor_texture :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> ^RenderPassAttachmentDescriptor { - return msgSend(^RenderPassAttachmentDescriptor, self, "texture") +RenderPassAttachmentDescriptor_texture :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> ^Texture { + return msgSend(^Texture, self, "texture") } //////////////////////////////////////////////////////////////////////////////// @@ -3000,16 +3000,16 @@ RenderPassDescriptor_depthAttachment :: #force_inline proc(self: ^RenderPassDesc return msgSend(^RenderPassDepthAttachmentDescriptor, self, "depthAttachment") } @(objc_type=RenderPassDescriptor, objc_name="getSamplePositions") -RenderPassDescriptor_getSamplePositions :: #force_inline proc(self: ^RenderPassDescriptor, positions: []SamplePosition) -> ^RenderPassDescriptor { - return msgSend(^RenderPassDescriptor, self, "getSamplePositions:count:", raw_data(positions), NS.UInteger(len(positions))) +RenderPassDescriptor_getSamplePositions :: #force_inline proc(self: ^RenderPassDescriptor, positions: []SamplePosition) -> NS.UInteger { + return msgSend(NS.UInteger, self, "getSamplePositions:count:", raw_data(positions), NS.UInteger(len(positions))) } @(objc_type=RenderPassDescriptor, objc_name="imageblockSampleLength") RenderPassDescriptor_imageblockSampleLength :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "imageblockSampleLength") } @(objc_type=RenderPassDescriptor, objc_name="rasterizationRateMap") -RenderPassDescriptor_rasterizationRateMap :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RenderPassDescriptor { - return msgSend(^RenderPassDescriptor, self, "rasterizationRateMap") +RenderPassDescriptor_rasterizationRateMap :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RasterizationRateMap { + return msgSend(^RasterizationRateMap, self, "rasterizationRateMap") } @(objc_type=RenderPassDescriptor, objc_class_name="renderPassDescriptor") RenderPassDescriptor_renderPassDescriptor :: #force_inline proc() -> ^RenderPassDescriptor { @@ -3144,8 +3144,8 @@ RenderPassSampleBufferAttachmentDescriptor_endOfVertexSampleIndex :: #force_inli return msgSend(NS.UInteger, self, "endOfVertexSampleIndex") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") -RenderPassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> ^Buffer { - return msgSend(^Buffer, self, "sampleBuffer") +RenderPassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> ^CounterSampleBuffer { + return msgSend(^CounterSampleBuffer, self, "sampleBuffer") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setEndOfFragmentSampleIndex") RenderPassSampleBufferAttachmentDescriptor_setEndOfFragmentSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, endOfFragmentSampleIndex: NS.UInteger) { @@ -3156,7 +3156,7 @@ RenderPassSampleBufferAttachmentDescriptor_setEndOfVertexSampleIndex :: #force_i msgSend(nil, self, "setEndOfVertexSampleIndex:", endOfVertexSampleIndex) } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") -RenderPassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, sampleBuffer: ^Buffer) { +RenderPassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, sampleBuffer: ^CounterSampleBuffer) { msgSend(nil, self, "setSampleBuffer:", sampleBuffer) } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setStartOfFragmentSampleIndex") From 7392a3047a91a182512b12dfb4826aec9af89dcc Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 16:58:56 +0000 Subject: [PATCH 53/64] Add RenderPipeline missing types and methods --- core/sys/darwin/Metal/MetalClasses.odin | 78 +++++++++++++++++++++++-- 1 file changed, 72 insertions(+), 6 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 1ad39e925..41c498378 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -3480,8 +3480,8 @@ RenderPipelineDescriptor_fragmentBuffers :: #force_inline proc(self: ^RenderPipe return msgSend(^PipelineBufferDescriptorArray, self, "fragmentBuffers") } @(objc_type=RenderPipelineDescriptor, objc_name="fragmentFunction") -RenderPipelineDescriptor_fragmentFunction :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineDescriptor { - return msgSend(^RenderPipelineDescriptor, self, "fragmentFunction") +RenderPipelineDescriptor_fragmentFunction :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^Function { + return msgSend(^Function, self, "fragmentFunction") } @(objc_type=RenderPipelineDescriptor, objc_name="inputPrimitiveTopology") RenderPipelineDescriptor_inputPrimitiveTopology :: #force_inline proc(self: ^RenderPipelineDescriptor) -> PrimitiveTopologyClass { @@ -3652,8 +3652,8 @@ RenderPipelineDescriptor_vertexDescriptor :: #force_inline proc(self: ^RenderPip return msgSend(^VertexDescriptor, self, "vertexDescriptor") } @(objc_type=RenderPipelineDescriptor, objc_name="vertexFunction") -RenderPipelineDescriptor_vertexFunction :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineDescriptor { - return msgSend(^RenderPipelineDescriptor, self, "vertexFunction") +RenderPipelineDescriptor_vertexFunction :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^Function { + return msgSend(^Function, self, "vertexFunction") } //////////////////////////////////////////////////////////////////////////////// @@ -7969,6 +7969,51 @@ RenderCommandEncoder_waitForFence :: #force_inline proc(self: ^RenderCommandEnco //////////////////////////////////////////////////////////////////////////////// +/* +Class: + RenderPipelineFunctionsDescriptor +*/ +@(objc_class="MTLRenderPipelineFunctionsDescriptor") +RenderPipelineFunctionsDescriptor :: struct { using _: NS.Copying(RenderPipelineFunctionsDescriptor) } + +@(objc_type=RenderPipelineFunctionsDescriptor, objc_class_name="alloc") +RenderPipelineFunctionsDescriptor_alloc :: #force_inline proc() -> ^RenderPipelineFunctionsDescriptor { + return msgSend(^RenderPipelineFunctionsDescriptor, RenderPipelineFunctionsDescriptor, "alloc") +} + +@(objc_type=RenderPipelineFunctionsDescriptor, objc_name="init") +RenderPipelineFunctionsDescriptor_init :: #force_inline proc(self: ^RenderPipelineFunctionsDescriptor) -> ^RenderPipelineFunctionsDescriptor { + return msgSend(^RenderPipelineFunctionsDescriptor, self, "init") +} + +@(objc_type=RenderPipelineFunctionsDescriptor, objc_name="vertexAdditionalBinaryFunctions") +RenderPipelineFunctionsDescriptor_vertexAdditionalBinaryFunctions :: #force_inline proc(self: ^RenderPipelineFunctionsDescriptor) -> ^NS.Array { + return msgSend(^NS.Array, self, "vertexAdditionalBinaryFunctions") +} +@(objc_type=RenderPipelineFunctionsDescriptor, objc_name="fragmentAdditionalBinaryFunctions") +RenderPipelineFunctionsDescriptor_fragmentAdditionalBinaryFunctions :: #force_inline proc(self: ^RenderPipelineFunctionsDescriptor) -> ^NS.Array { + return msgSend(^NS.Array, self, "fragmentAdditionalBinaryFunctions") +} +@(objc_type=RenderPipelineFunctionsDescriptor, objc_name="tileAdditionalBinaryFunctions") +RenderPipelineFunctionsDescriptor_tileAdditionalBinaryFunctions :: #force_inline proc(self: ^RenderPipelineFunctionsDescriptor) -> ^NS.Array { + return msgSend(^NS.Array, self, "tileAdditionalBinaryFunctions") +} + +@(objc_type=RenderPipelineFunctionsDescriptor, objc_name="setVertexAdditionalBinaryFunctions") +RenderPipelineFunctionsDescriptor_setVertexAdditionalBinaryFunctions :: #force_inline proc(self: ^RenderPipelineFunctionsDescriptor, binaryFunctions: ^NS.Array) { + msgSend(nil, self, "setVertexAdditionalBinaryFunctions:", binaryFunctions) +} +@(objc_type=RenderPipelineFunctionsDescriptor, objc_name="setFragmentAdditionalBinaryFunctions") +RenderPipelineFunctionsDescriptor_setFragmentAdditionalBinaryFunctions :: #force_inline proc(self: ^RenderPipelineFunctionsDescriptor, binaryFunctions: ^NS.Array) { + msgSend(nil, self, "setFragmentAdditionalBinaryFunctions:", binaryFunctions) +} +@(objc_type=RenderPipelineFunctionsDescriptor, objc_name="setTileAdditionalBinaryFunctions") +RenderPipelineFunctionsDescriptor_setTileAdditionalBinaryFunctions :: #force_inline proc(self: ^RenderPipelineFunctionsDescriptor, binaryFunctions: ^NS.Array) { + msgSend(nil, self, "tileAdditionalBinaryFunctions:", binaryFunctions) +} + +//////////////////////////////////////////////////////////////////////////////// + /* Class: RenderPipelineState @@ -7990,8 +8035,8 @@ RenderPipelineState_device :: #force_inline proc(self: ^RenderPipelineState) -> return msgSend(^Device, self, "device") } @(objc_type=RenderPipelineState, objc_name="imageblockMemoryLengthForDimensions") -RenderPipelineState_imageblockMemoryLengthForDimensions :: #force_inline proc(self: ^RenderPipelineState, imageblockDimensions: Size) -> ^RenderPipelineState { - return msgSend(^RenderPipelineState, self, "imageblockMemoryLengthForDimensions:", imageblockDimensions) +RenderPipelineState_imageblockMemoryLengthForDimensions :: #force_inline proc(self: ^RenderPipelineState, imageblockDimensions: Size) -> NS.UInteger { + return msgSend(NS.UInteger, self, "imageblockMemoryLengthForDimensions:", imageblockDimensions) } @(objc_type=RenderPipelineState, objc_name="imageblockSampleLength") RenderPipelineState_imageblockSampleLength :: #force_inline proc(self: ^RenderPipelineState) -> NS.UInteger { @@ -8014,6 +8059,27 @@ RenderPipelineState_threadgroupSizeMatchesTileSize :: #force_inline proc(self: ^ return msgSend(BOOL, self, "threadgroupSizeMatchesTileSize") } +@(objc_type=RenderPipelineState, objc_name="functionHandle") +RenderPipelineState_functionHandle :: #force_inline proc(self: ^RenderPipelineState, function: ^Function, stage: RenderStages) -> ^FunctionHandle { + return msgSend(^FunctionHandle, self, "functionHandleWithFunction:stage:", function, stage) +} + +@(objc_type=RenderPipelineState, objc_name="newVisibleFunctionTable") +RenderPipelineState_newVisibleFunctionTable :: #force_inline proc(self: ^RenderPipelineState, descriptor: ^VisibleFunctionTableDescriptor, stage: RenderStages) -> ^VisibleFunctionTable { + return msgSend(^VisibleFunctionTable, self, "newVisibleFunctionTableWithDescriptor:stage:", descriptor, stage) +} + +@(objc_type=RenderPipelineState, objc_name="newIntersectionFunctionTable") +RenderPipelineState_newIntersectionFunctionTable :: #force_inline proc(self: ^RenderPipelineState, descriptor: ^IntersectionFunctionTableDescriptor, stage: RenderStages) -> ^IntersectionFunctionTable { + return msgSend(^IntersectionFunctionTable, self, "newIntersectionFunctionTable:stage:", descriptor, stage) +} + +@(objc_type=RenderPipelineState, objc_name="newRenderPipelineState") +RenderPipelineState_newRenderPipelineState :: #force_inline proc(self: ^RenderPipelineState, additionalBinaryFunctions: ^RenderPipelineFunctionsDescriptor) -> (state: ^RenderPipelineState, error: ^NS.Error) { + state = msgSend(^RenderPipelineState, self, "newRenderPipelineStateWithAdditionalBinaryFunctions:error:", additionalBinaryFunctions, &error) + return +} + //////////////////////////////////////////////////////////////////////////////// /* From 3d2405ac2c1eb135688b060b383e1cdd5dcc739f Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 17:02:05 +0000 Subject: [PATCH 54/64] Correct more method types --- core/sys/darwin/Metal/MetalClasses.odin | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 41c498378..6994b3181 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -4696,8 +4696,8 @@ TileRenderPipelineDescriptor_tileBuffers :: #force_inline proc(self: ^TileRender return msgSend(^PipelineBufferDescriptorArray, self, "tileBuffers") } @(objc_type=TileRenderPipelineDescriptor, objc_name="tileFunction") -TileRenderPipelineDescriptor_tileFunction :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> ^TileRenderPipelineDescriptor { - return msgSend(^TileRenderPipelineDescriptor, self, "tileFunction") +TileRenderPipelineDescriptor_tileFunction :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> ^Function { + return msgSend(^Function, self, "tileFunction") } //////////////////////////////////////////////////////////////////////////////// @@ -8121,8 +8121,8 @@ Resource_hazardTrackingMode :: #force_inline proc(self: ^Resource) -> HazardTrac return msgSend(HazardTrackingMode, self, "hazardTrackingMode") } @(objc_type=Resource, objc_name="heap") -Resource_heap :: #force_inline proc(self: ^Resource) -> ^Resource { - return msgSend(^Resource, self, "heap") +Resource_heap :: #force_inline proc(self: ^Resource) -> ^Heap { + return msgSend(^Heap, self, "heap") } @(objc_type=Resource, objc_name="heapOffset") Resource_heapOffset :: #force_inline proc(self: ^Resource) -> NS.UInteger { @@ -8186,8 +8186,8 @@ ResourceStateCommandEncoder_updateTextureMapping :: #force_inline proc(self: ^Re msgSend(nil, self, "updateTextureMapping:mode:region:mipLevel:slice:", texture, mode, region, mipLevel, slice) } @(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMappings") -ResourceStateCommandEncoder_updateTextureMappings :: #force_inline proc(self: ^ResourceStateCommandEncoder, texture: ^Texture, mode: SparseTextureMappingMode, regions: ^Region, mipLevels: NS.UInteger, slices: NS.UInteger, numRegions: NS.UInteger) { - msgSend(nil, self, "updateTextureMappings:mode:regions:mipLevels:slices:numRegions:", texture, mode, regions, mipLevels, slices, numRegions) +ResourceStateCommandEncoder_updateTextureMappings :: #force_inline proc(self: ^ResourceStateCommandEncoder, texture: ^Texture, mode: SparseTextureMappingMode, regions: []Region, mipLevels: []NS.UInteger, slices: NS.UInteger) { + msgSend(nil, self, "updateTextureMappings:mode:regions:mipLevels:slices:numRegions:", texture, mode, raw_data(regions), raw_data(mipLevels), slices, NS.UInteger(len(regions))) } @(objc_type=ResourceStateCommandEncoder, objc_name="waitForFence") ResourceStateCommandEncoder_waitForFence :: #force_inline proc(self: ^ResourceStateCommandEncoder, fence: ^Fence) { From 643e36b87bb320818dcc9656ee1137dba9e74217 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 17:07:18 +0000 Subject: [PATCH 55/64] Improve Texture method names --- core/sys/darwin/Metal/MetalClasses.odin | 50 ++++++++++++------------- 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 6994b3181..af9f03518 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -3757,15 +3757,15 @@ ResourceStatePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #fo return msgSend(NS.UInteger, self, "endOfEncoderSampleIndex") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") -ResourceStatePassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> ^Buffer { - return msgSend(^Buffer, self, "sampleBuffer") +ResourceStatePassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> ^CounterSampleBuffer { + return msgSend(^CounterSampleBuffer, self, "sampleBuffer") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex") ResourceStatePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.UInteger) { msgSend(nil, self, "setEndOfEncoderSampleIndex:", endOfEncoderSampleIndex) } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") -ResourceStatePassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, sampleBuffer: ^Buffer) { +ResourceStatePassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, sampleBuffer: ^CounterSampleBuffer) { msgSend(nil, self, "setSampleBuffer:", sampleBuffer) } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="setStartOfEncoderSampleIndex") @@ -4472,16 +4472,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_class_name="texture2DDescriptorWithPixelFormat") -TextureDescriptor_texture2DDescriptorWithPixelFormat :: #force_inline proc(pixelFormat: PixelFormat, width: NS.UInteger, height: NS.UInteger, mipmapped: BOOL) -> ^TextureDescriptor { +@(objc_type=TextureDescriptor, objc_class_name="texture2DDescriptor") +TextureDescriptor_texture2DDescriptor :: #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_class_name="textureBufferDescriptorWithPixelFormat") -TextureDescriptor_textureBufferDescriptorWithPixelFormat :: #force_inline proc(pixelFormat: PixelFormat, width: NS.UInteger, resourceOptions: ResourceOptions, usage: TextureUsage) -> ^TextureDescriptor { +@(objc_type=TextureDescriptor, objc_class_name="textureBufferDescriptor") +TextureDescriptor_textureBufferDescriptor :: #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_class_name="textureCubeDescriptorWithPixelFormat") -TextureDescriptor_textureCubeDescriptorWithPixelFormat :: #force_inline proc(pixelFormat: PixelFormat, size: NS.UInteger, mipmapped: BOOL) -> ^TextureDescriptor { +@(objc_type=TextureDescriptor, objc_class_name="textureCubeDescriptor") +TextureDescriptor_textureCubeDescriptor :: #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") @@ -8322,12 +8322,12 @@ Texture_depth :: #force_inline proc(self: ^Texture) -> NS.UInteger { Texture_firstMipmapInTail :: #force_inline proc(self: ^Texture) -> NS.UInteger { return msgSend(NS.UInteger, self, "firstMipmapInTail") } -@(objc_type=Texture, objc_name="getBytes_bytesPerRow_bytesPerImage_fromRegion_mipmapLevel_slice_") -Texture_getBytes_bytesPerRow_bytesPerImage_fromRegion_mipmapLevel_slice_ :: #force_inline proc(self: ^Texture, pixelBytes: rawptr, bytesPerRow: NS.UInteger, bytesPerImage: NS.UInteger, region: Region, level: NS.UInteger, slice: NS.UInteger) { +@(objc_type=Texture, objc_name="getBytesWithLevel") +Texture_getBytesWithLevel :: #force_inline proc(self: ^Texture, pixelBytes: rawptr, bytesPerRow: NS.UInteger, bytesPerImage: NS.UInteger, region: Region, level: NS.UInteger, slice: NS.UInteger) { msgSend(nil, self, "getBytes:bytesPerRow:bytesPerImage:fromRegion:mipmapLevel:slice:", pixelBytes, bytesPerRow, bytesPerImage, region, level, slice) } -@(objc_type=Texture, objc_name="getBytes_bytesPerRow_fromRegion_mipmapLevel_") -Texture_getBytes_bytesPerRow_fromRegion_mipmapLevel_ :: #force_inline proc(self: ^Texture, pixelBytes: rawptr, bytesPerRow: NS.UInteger, region: Region, level: NS.UInteger) { +@(objc_type=Texture, objc_name="getBytes") +Texture_getBytes :: #force_inline proc(self: ^Texture, pixelBytes: rawptr, bytesPerRow: NS.UInteger, region: Region, level: NS.UInteger) { msgSend(nil, self, "getBytes:bytesPerRow:fromRegion:mipmapLevel:", pixelBytes, bytesPerRow, region, level) } @(objc_type=Texture, objc_name="height") @@ -8366,16 +8366,16 @@ Texture_newRemoteTextureViewForDevice :: #force_inline proc(self: ^Texture, devi Texture_newSharedTextureHandle :: #force_inline proc(self: ^Texture) -> ^SharedTextureHandle { return msgSend(^SharedTextureHandle, self, "newSharedTextureHandle") } -@(objc_type=Texture, objc_name="newTextureViewWithPixelFormat") -Texture_newTextureViewWithPixelFormat :: #force_inline proc(self: ^Texture, pixelFormat: PixelFormat) -> ^Texture { +@(objc_type=Texture, objc_name="newTextureView") +Texture_newTextureView :: #force_inline proc(self: ^Texture, pixelFormat: PixelFormat) -> ^Texture { return msgSend(^Texture, self, "newTextureViewWithPixelFormat:", pixelFormat) } -@(objc_type=Texture, objc_name="newTextureViewWithPixelFormat_textureType_levels_slices_") -Texture_newTextureViewWithPixelFormat_textureType_levels_slices_ :: #force_inline proc(self: ^Texture, pixelFormat: PixelFormat, textureType: TextureType, levelRange: NS.Range, sliceRange: NS.Range) -> ^Texture { +@(objc_type=Texture, objc_name="newTextureViewWithLevels") +Texture_newTextureViewWithLevels :: #force_inline proc(self: ^Texture, pixelFormat: PixelFormat, textureType: TextureType, levelRange: NS.Range, sliceRange: NS.Range) -> ^Texture { return msgSend(^Texture, self, "newTextureViewWithPixelFormat:textureType:levels:slices:", pixelFormat, textureType, levelRange, sliceRange) } -@(objc_type=Texture, objc_name="newTextureViewWithPixelFormat_textureType_levels_slices_swizzle_") -Texture_newTextureViewWithPixelFormat_textureType_levels_slices_swizzle_ :: #force_inline proc(self: ^Texture, pixelFormat: PixelFormat, textureType: TextureType, levelRange: NS.Range, sliceRange: NS.Range, swizzle: TextureSwizzleChannels) -> ^Texture { +@(objc_type=Texture, objc_name="newTextureViewWithLevelsAndSwizzle") +Texture_newTextureViewWithLevelsAndSwizzle :: #force_inline proc(self: ^Texture, pixelFormat: PixelFormat, textureType: TextureType, levelRange: NS.Range, sliceRange: NS.Range, swizzle: TextureSwizzleChannels) -> ^Texture { return msgSend(^Texture, self, "newTextureViewWithPixelFormat:textureType:levels:slices:swizzle:", pixelFormat, textureType, levelRange, sliceRange, swizzle) } @(objc_type=Texture, objc_name="parentRelativeLevel") @@ -8398,17 +8398,17 @@ Texture_pixelFormat :: #force_inline proc(self: ^Texture) -> PixelFormat { Texture_remoteStorageTexture :: #force_inline proc(self: ^Texture) -> ^Texture { return msgSend(^Texture, self, "remoteStorageTexture") } -@(objc_type=Texture, objc_name="replaceRegion_mipmapLevel_slice_withBytes_bytesPerRow_bytesPerImage_") -Texture_replaceRegion_mipmapLevel_slice_withBytes_bytesPerRow_bytesPerImage_ :: #force_inline proc(self: ^Texture, region: Region, level: NS.UInteger, slice: NS.UInteger, pixelBytes: rawptr, bytesPerRow: NS.UInteger, bytesPerImage: NS.UInteger) { +@(objc_type=Texture, objc_name="replaceRegionWithLevel") +Texture_replaceRegionWithLevel :: #force_inline proc(self: ^Texture, region: Region, level: NS.UInteger, slice: NS.UInteger, pixelBytes: rawptr, bytesPerRow: NS.UInteger, bytesPerImage: NS.UInteger) { msgSend(nil, self, "replaceRegion:mipmapLevel:slice:withBytes:bytesPerRow:bytesPerImage:", region, level, slice, pixelBytes, bytesPerRow, bytesPerImage) } -@(objc_type=Texture, objc_name="replaceRegion_mipmapLevel_withBytes_bytesPerRow_") -Texture_replaceRegion_mipmapLevel_withBytes_bytesPerRow_ :: #force_inline proc(self: ^Texture, region: Region, level: NS.UInteger, pixelBytes: rawptr, bytesPerRow: NS.UInteger) { +@(objc_type=Texture, objc_name="replaceRegion") +Texture_replaceRegion :: #force_inline proc(self: ^Texture, region: Region, level: NS.UInteger, pixelBytes: rawptr, bytesPerRow: NS.UInteger) { msgSend(nil, self, "replaceRegion:mipmapLevel:withBytes:bytesPerRow:", region, level, pixelBytes, bytesPerRow) } @(objc_type=Texture, objc_name="rootResource") -Texture_rootResource :: #force_inline proc(self: ^Texture) -> ^Texture { - return msgSend(^Texture, self, "rootResource") +Texture_rootResource :: #force_inline proc(self: ^Texture) -> ^Resource { + return msgSend(^Resource, self, "rootResource") } @(objc_type=Texture, objc_name="sampleCount") Texture_sampleCount :: #force_inline proc(self: ^Texture) -> NS.UInteger { From 1afa7967f23adcf84466db830c899cbb17521acc Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 17:09:30 +0000 Subject: [PATCH 56/64] Fix method names --- core/sys/darwin/Metal/MetalClasses.odin | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index af9f03518..3a0e32c9f 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -5184,7 +5184,7 @@ ArgumentEncoder_setAccelerationStructure :: #force_inline proc(self: ^ArgumentEn ArgumentEncoder_setArgumentBufferWithOffset :: #force_inline proc(self: ^ArgumentEncoder, argumentBuffer: ^Buffer, offset: NS.UInteger) { msgSend(nil, self, "setArgumentBuffer:offset:", argumentBuffer, offset) } -@(objc_type=ArgumentEncoder, objc_name="setArgumentBuffer_startOffsetWithStartOffset") +@(objc_type=ArgumentEncoder, objc_name="setArgumentBufferWithStartOffset") ArgumentEncoder_setArgumentBuffer_startOffsetWithStartOffset :: #force_inline proc(self: ^ArgumentEncoder, argumentBuffer: ^Buffer, startOffset: NS.UInteger, arrayElement: NS.UInteger) { msgSend(nil, self, "setArgumentBuffer:startOffset:arrayElement:", argumentBuffer, startOffset, arrayElement) } @@ -5998,7 +5998,7 @@ ComputeCommandEncoder_setIntersectionFunctionTables :: #force_inline proc(self: ComputeCommandEncoder_setSamplerState :: #force_inline proc(self: ^ComputeCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { msgSend(nil, self, "setSamplerState:atIndex:", sampler, index) } -@(objc_type=ComputeCommandEncoder, objc_name="setSamplerState_lodMinClamp_lodMaxClamp") +@(objc_type=ComputeCommandEncoder, objc_name="setSamplerStateWithLod") ComputeCommandEncoder_setSamplerState_lodMinClamp_lodMaxClamp :: #force_inline proc(self: ^ComputeCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { msgSend(nil, self, "setSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } From e69738c0791b74ce50d120a35f0274593185f727 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 17:23:14 +0000 Subject: [PATCH 57/64] Minor style change --- core/sys/darwin/Metal/MetalClasses.odin | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 3a0e32c9f..7472fa37b 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -5203,7 +5203,7 @@ ArgumentEncoder_setComputePipelineState :: #force_inline proc(self: ^ArgumentEnc } @(objc_type=ArgumentEncoder, objc_name="setComputePipelineStates") ArgumentEncoder_setComputePipelineStates :: #force_inline proc(self: ^ArgumentEncoder, pipelines: []^ComputePipelineState, range: NS.Range) { - assert(range.length <= NS.UInteger(len(pipelines))) + assert(range.length <= NS.UInteger(len(pipelines))) msgSend(nil, self, "setComputePipelineStates:withRange:", raw_data(pipelines), range) } @(objc_type=ArgumentEncoder, objc_name="setIndirectCommandBuffer") @@ -5212,7 +5212,7 @@ ArgumentEncoder_setIndirectCommandBuffer :: #force_inline proc(self: ^ArgumentEn } @(objc_type=ArgumentEncoder, objc_name="setIndirectCommandBuffers") ArgumentEncoder_setIndirectCommandBuffers :: #force_inline proc(self: ^ArgumentEncoder, buffers: []^IndirectCommandBuffer, range: NS.Range) { - assert(range.length <= NS.UInteger(len(buffers))) + assert(range.length <= NS.UInteger(len(buffers))) msgSend(nil, self, "setIndirectCommandBuffers:withRange:", raw_data(buffers), range) } @(objc_type=ArgumentEncoder, objc_name="setIntersectionFunctionTable") @@ -5221,7 +5221,7 @@ ArgumentEncoder_setIntersectionFunctionTable :: #force_inline proc(self: ^Argume } @(objc_type=ArgumentEncoder, objc_name="setIntersectionFunctionTables") ArgumentEncoder_setIntersectionFunctionTables :: #force_inline proc(self: ^ArgumentEncoder, intersectionFunctionTables: []^IntersectionFunctionTable, range: NS.Range) { - assert(range.length <= NS.UInteger(len(intersectionFunctionTables))) + assert(range.length <= NS.UInteger(len(intersectionFunctionTables))) msgSend(nil, self, "setIntersectionFunctionTables:withRange:", raw_data(intersectionFunctionTables), range) } @(objc_type=ArgumentEncoder, objc_name="setLabel") @@ -5234,7 +5234,7 @@ ArgumentEncoder_setRenderPipelineState :: #force_inline proc(self: ^ArgumentEnco } @(objc_type=ArgumentEncoder, objc_name="setRenderPipelineStates") ArgumentEncoder_setRenderPipelineStates :: #force_inline proc(self: ^ArgumentEncoder, pipelines: []^RenderPipelineState, range: NS.Range) { - assert(range.length <= NS.UInteger(len(pipelines))) + assert(range.length <= NS.UInteger(len(pipelines))) msgSend(nil, self, "setRenderPipelineStates:withRange:", raw_data(pipelines), range) } @(objc_type=ArgumentEncoder, objc_name="setSamplerState") @@ -5243,7 +5243,7 @@ ArgumentEncoder_setSamplerState :: #force_inline proc(self: ^ArgumentEncoder, sa } @(objc_type=ArgumentEncoder, objc_name="setSamplerStates") ArgumentEncoder_setSamplerStates :: #force_inline proc(self: ^ArgumentEncoder, samplers: []^SamplerState, range: NS.Range) { - assert(range.length <= NS.UInteger(len(samplers))) + assert(range.length <= NS.UInteger(len(samplers))) msgSend(nil, self, "setSamplerStates:withRange:", raw_data(samplers), range) } @(objc_type=ArgumentEncoder, objc_name="setTexture") @@ -5252,7 +5252,7 @@ ArgumentEncoder_setTexture :: #force_inline proc(self: ^ArgumentEncoder, texture } @(objc_type=ArgumentEncoder, objc_name="setTextures") ArgumentEncoder_setTextures :: #force_inline proc(self: ^ArgumentEncoder, textures: []^Texture, range: NS.Range) { - assert(range.length <= NS.UInteger(len(textures))) + assert(range.length <= NS.UInteger(len(textures))) msgSend(nil, self, "setTextures:withRange:", raw_data(textures), range) } @(objc_type=ArgumentEncoder, objc_name="setVisibleFunctionTable") @@ -5261,7 +5261,7 @@ ArgumentEncoder_setVisibleFunctionTable :: #force_inline proc(self: ^ArgumentEnc } @(objc_type=ArgumentEncoder, objc_name="setVisibleFunctionTables") ArgumentEncoder_setVisibleFunctionTables :: #force_inline proc(self: ^ArgumentEncoder, visibleFunctionTables: []^VisibleFunctionTable, range: NS.Range) { - assert(range.length <= NS.UInteger(len(visibleFunctionTables))) + assert(range.length <= NS.UInteger(len(visibleFunctionTables))) msgSend(nil, self, "setVisibleFunctionTables:withRange:", raw_data(visibleFunctionTables), range) } @@ -5970,7 +5970,7 @@ ComputeCommandEncoder_setBufferOffset :: #force_inline proc(self: ^ComputeComman @(objc_type=ComputeCommandEncoder, objc_name="setBuffers") ComputeCommandEncoder_setBuffers :: #force_inline proc(self: ^ComputeCommandEncoder, buffers: []^Buffer, offsets: []NS.UInteger, range: NS.Range) { assert(len(buffers) == len(offsets)) - assert(range.length <= NS.UInteger(len(buffers))) + assert(range.length <= NS.UInteger(len(buffers))) msgSend(nil, self, "setBuffers:offsets:withRange:", raw_data(buffers), raw_data(offsets), range) } @(objc_type=ComputeCommandEncoder, objc_name="setBytes") @@ -5991,7 +5991,7 @@ ComputeCommandEncoder_setIntersectionFunctionTable :: #force_inline proc(self: ^ } @(objc_type=ComputeCommandEncoder, objc_name="setIntersectionFunctionTables") ComputeCommandEncoder_setIntersectionFunctionTables :: #force_inline proc(self: ^ComputeCommandEncoder, intersectionFunctionTables: []^IntersectionFunctionTable, range: NS.Range) { - assert(range.length <= NS.UInteger(len(intersectionFunctionTables))) + assert(range.length <= NS.UInteger(len(intersectionFunctionTables))) msgSend(nil, self, "setIntersectionFunctionTables:withBufferRange:", raw_data(intersectionFunctionTables), range) } @(objc_type=ComputeCommandEncoder, objc_name="setSamplerState") From 03aec70287714fb9d66864e6db0d9e6375c18362 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 17:31:55 +0000 Subject: [PATCH 58/64] Change objc_class_name to objc_name with objc_is_class_method --- core/sys/darwin/Foundation/NSArray.odin | 2 +- .../darwin/Foundation/NSAutoreleasePool.odin | 2 +- core/sys/darwin/Foundation/NSBundle.odin | 8 +- core/sys/darwin/Foundation/NSData.odin | 2 +- core/sys/darwin/Foundation/NSDate.odin | 2 +- core/sys/darwin/Foundation/NSDictionary.odin | 8 +- core/sys/darwin/Foundation/NSEnumerator.odin | 2 +- core/sys/darwin/Foundation/NSError.odin | 4 +- core/sys/darwin/Foundation/NSLock.odin | 2 +- .../sys/darwin/Foundation/NSNotification.odin | 2 +- core/sys/darwin/Foundation/NSNumber.odin | 34 +-- core/sys/darwin/Foundation/NSString.odin | 2 +- core/sys/darwin/Foundation/NSURL.odin | 2 +- core/sys/darwin/Metal/MetalClasses.odin | 226 +++++++++--------- core/sys/darwin/QuartzCore/QuartzCore.odin | 2 +- src/check_decl.cpp | 24 +- src/checker.cpp | 12 +- src/checker.hpp | 2 +- 18 files changed, 166 insertions(+), 172 deletions(-) diff --git a/core/sys/darwin/Foundation/NSArray.odin b/core/sys/darwin/Foundation/NSArray.odin index e17223ff7..d6021838b 100644 --- a/core/sys/darwin/Foundation/NSArray.odin +++ b/core/sys/darwin/Foundation/NSArray.odin @@ -7,7 +7,7 @@ Array :: struct { using _: Copying(Array), } -@(objc_type=Array, objc_class_name="alloc") +@(objc_type=Array, objc_name="alloc", objc_is_class_method=true) Array_alloc :: proc() -> ^Array { return msgSend(^Array, Array, "alloc") } diff --git a/core/sys/darwin/Foundation/NSAutoreleasePool.odin b/core/sys/darwin/Foundation/NSAutoreleasePool.odin index 17ec88ba1..a388a7146 100644 --- a/core/sys/darwin/Foundation/NSAutoreleasePool.odin +++ b/core/sys/darwin/Foundation/NSAutoreleasePool.odin @@ -3,7 +3,7 @@ package objc_Foundation @(objc_class="NSAutoreleasePool") AutoreleasePool :: struct {using _: Object} -@(objc_type=AutoreleasePool, objc_class_name="alloc") +@(objc_type=AutoreleasePool, objc_name="alloc", objc_is_class_method=true) AutoreleasePool_alloc :: proc() -> ^AutoreleasePool { return msgSend(^AutoreleasePool, AutoreleasePool, "alloc") } diff --git a/core/sys/darwin/Foundation/NSBundle.odin b/core/sys/darwin/Foundation/NSBundle.odin index a18809b7e..4f5a8e928 100644 --- a/core/sys/darwin/Foundation/NSBundle.odin +++ b/core/sys/darwin/Foundation/NSBundle.odin @@ -3,23 +3,23 @@ package objc_Foundation @(objc_class="NSBundle") Bundle :: struct { using _: Object } -@(objc_type=Bundle, objc_class_name="mainBundle") +@(objc_type=Bundle, objc_name="mainBundle", objc_is_class_method=true) Bundle_mainBundle :: proc() -> ^Bundle { return msgSend(^Bundle, Bundle, "mainBundle") } -@(objc_type=Bundle, objc_class_name="bundleWithPath") +@(objc_type=Bundle, objc_name="bundleWithPath", objc_is_class_method=true) Bundle_bundleWithPath :: proc(path: ^String) -> ^Bundle { return msgSend(^Bundle, Bundle, "bundleWithPath:", path) } -@(objc_type=Bundle, objc_class_name="bundleWithURL") +@(objc_type=Bundle, objc_name="bundleWithURL", objc_is_class_method=true) Bundle_bundleWithURL :: proc(url: ^URL) -> ^Bundle { return msgSend(^Bundle, Bundle, "bundleWithUrl:", url) } -@(objc_type=Bundle, objc_class_name="alloc") +@(objc_type=Bundle, objc_name="alloc", objc_is_class_method=true) Bundle_alloc :: proc() -> ^Bundle { return msgSend(^Bundle, Bundle, "alloc") } diff --git a/core/sys/darwin/Foundation/NSData.odin b/core/sys/darwin/Foundation/NSData.odin index e28f6a644..3c6369e86 100644 --- a/core/sys/darwin/Foundation/NSData.odin +++ b/core/sys/darwin/Foundation/NSData.odin @@ -3,7 +3,7 @@ package objc_Foundation @(objc_class="NSData") Data :: struct {using _: Copying(Data)} -@(objc_type=Data, objc_class_name="alloc") +@(objc_type=Data, objc_name="alloc", objc_is_class_method=true) Data_alloc :: proc() -> ^Data { return msgSend(^Data, Data, "alloc") } diff --git a/core/sys/darwin/Foundation/NSDate.odin b/core/sys/darwin/Foundation/NSDate.odin index 85bb14c3e..cd63d313a 100644 --- a/core/sys/darwin/Foundation/NSDate.odin +++ b/core/sys/darwin/Foundation/NSDate.odin @@ -3,7 +3,7 @@ package objc_Foundation @(objc_class="NSDate") Date :: struct {using _: Copying(Date)} -@(objc_type=Date, objc_class_name="alloc") +@(objc_type=Date, objc_name="alloc", objc_is_class_method=true) Date_alloc :: proc() -> ^Date { return msgSend(^Date, Date, "alloc") } diff --git a/core/sys/darwin/Foundation/NSDictionary.odin b/core/sys/darwin/Foundation/NSDictionary.odin index 3eb378dc7..1f009841a 100644 --- a/core/sys/darwin/Foundation/NSDictionary.odin +++ b/core/sys/darwin/Foundation/NSDictionary.odin @@ -3,23 +3,23 @@ package objc_Foundation @(objc_class="NSDictionary") Dictionary :: struct {using _: Copying(Dictionary)} -@(objc_type=Dictionary, objc_class_name="dictionary") +@(objc_type=Dictionary, objc_name="dictionary", objc_is_class_method=true) Dictionary_dictionary :: proc() -> ^Dictionary { return msgSend(^Dictionary, Dictionary, "dictionary") } -@(objc_type=Dictionary, objc_class_name="dictionaryWithObject") +@(objc_type=Dictionary, objc_name="dictionaryWithObject", objc_is_class_method=true) Dictionary_dictionaryWithObject :: proc(object: ^Object, forKey: ^Object) -> ^Dictionary { return msgSend(^Dictionary, Dictionary, "dictionaryWithObject:forKey:", object, forKey) } -@(objc_type=Dictionary, objc_class_name="dictionaryWithObjects") +@(objc_type=Dictionary, objc_name="dictionaryWithObjects", objc_is_class_method=true) Dictionary_dictionaryWithObjects :: proc(objects: [^]^Object, forKeys: [^]^Object, count: UInteger) -> ^Dictionary { return msgSend(^Dictionary, Dictionary, "dictionaryWithObjects:forKeys:count", objects, forKeys, count) } -@(objc_type=Dictionary, objc_class_name="alloc") +@(objc_type=Dictionary, objc_name="alloc", objc_is_class_method=true) Dictionary_alloc :: proc() -> ^Dictionary { return msgSend(^Dictionary, Dictionary, "alloc") } diff --git a/core/sys/darwin/Foundation/NSEnumerator.odin b/core/sys/darwin/Foundation/NSEnumerator.odin index 8a5a32e69..1c7ddeed2 100644 --- a/core/sys/darwin/Foundation/NSEnumerator.odin +++ b/core/sys/darwin/Foundation/NSEnumerator.odin @@ -19,7 +19,7 @@ Enumerator :: struct($T: typeid) where intrinsics.type_is_pointer(T), intrinsics } -@(objc_type=FastEnumeration, objc_class_name="alloc") +@(objc_type=FastEnumeration, objc_name="alloc", objc_is_class_method=true) FastEnumeration_alloc :: proc() -> ^FastEnumeration { return msgSend(^FastEnumeration, FastEnumeration, "alloc") } diff --git a/core/sys/darwin/Foundation/NSError.odin b/core/sys/darwin/Foundation/NSError.odin index bff0088e9..23e6eaba7 100644 --- a/core/sys/darwin/Foundation/NSError.odin +++ b/core/sys/darwin/Foundation/NSError.odin @@ -32,7 +32,7 @@ foreign Foundation { Error :: struct { using _: Copying(Error) } -@(objc_type=Error, objc_class_name="alloc") +@(objc_type=Error, objc_name="alloc", objc_is_class_method=true) Error_alloc :: proc() -> ^Error { return msgSend(^Error, Error, "alloc") } @@ -42,7 +42,7 @@ Error_init :: proc(self: ^Error) -> ^Error { return msgSend(^Error, self, "init") } -@(objc_type=Error, objc_class_name="errorWithDomain") +@(objc_type=Error, objc_name="errorWithDomain", objc_is_class_method=true) Error_errorWithDomain :: proc(domain: ErrorDomain, code: Integer, userInfo: ^Dictionary) -> ^Error { return msgSend(^Error, Error, "errorWithDomain:code:userInfo:", domain, code, userInfo) } diff --git a/core/sys/darwin/Foundation/NSLock.odin b/core/sys/darwin/Foundation/NSLock.odin index 3bcc06eab..c48b5dbad 100644 --- a/core/sys/darwin/Foundation/NSLock.odin +++ b/core/sys/darwin/Foundation/NSLock.odin @@ -13,7 +13,7 @@ Locking_unlock :: proc(self: ^Locking($T)) { Condition :: struct {using _: Locking(Condition) } -@(objc_type=Condition, objc_class_name="alloc") +@(objc_type=Condition, objc_name="alloc", objc_is_class_method=true) Condition_alloc :: proc() -> ^Condition { return msgSend(^Condition, Condition, "alloc") } diff --git a/core/sys/darwin/Foundation/NSNotification.odin b/core/sys/darwin/Foundation/NSNotification.odin index d8b142e53..182d33896 100644 --- a/core/sys/darwin/Foundation/NSNotification.odin +++ b/core/sys/darwin/Foundation/NSNotification.odin @@ -4,7 +4,7 @@ package objc_Foundation Notification :: struct{using _: Object} -@(objc_type=Notification, objc_class_name="alloc") +@(objc_type=Notification, objc_name="alloc", objc_is_class_method=true) Notification_alloc :: proc() -> ^Notification { return msgSend(^Notification, Notification, "alloc") } diff --git a/core/sys/darwin/Foundation/NSNumber.odin b/core/sys/darwin/Foundation/NSNumber.odin index f77b0866a..4f7ef311b 100644 --- a/core/sys/darwin/Foundation/NSNumber.odin +++ b/core/sys/darwin/Foundation/NSNumber.odin @@ -8,7 +8,7 @@ import "core:c" @(objc_class="NSValue") Value :: struct{using _: Copying(Value)} -@(objc_type=Value, objc_class_name="alloc") +@(objc_type=Value, objc_name="alloc", objc_is_class_method=true) Value_alloc :: proc() -> ^Value { return msgSend(^Value, Value, "alloc") } @@ -18,12 +18,12 @@ Value_init :: proc(self: ^Value) -> ^Value { return msgSend(^Value, self, "init") } -@(objc_type=Value, objc_class_name="valueWithBytes") +@(objc_type=Value, objc_name="valueWithBytes", objc_is_class_method=true) Value_valueWithBytes :: proc(value: rawptr, type: cstring) -> ^Value { return msgSend(^Value, Value, "valueWithBytes:objCType:", value, type) } -@(objc_type=Value, objc_class_name="valueWithPointer") +@(objc_type=Value, objc_name="valueWithPointer", objc_is_class_method=true) Value_valueWithPointer :: proc(pointer: rawptr) -> ^Value { return msgSend(^Value, Value, "valueWithPointer:", pointer) } @@ -64,7 +64,7 @@ Value_pointerValue :: proc(self: ^Value) -> rawptr { Number :: struct{using _: Copying(Number), using _: Value} -@(objc_type=Number, objc_class_name="alloc") +@(objc_type=Number, objc_name="alloc", objc_is_class_method=true) Number_alloc :: proc() -> ^Number { return msgSend(^Number, Number, "alloc") } @@ -74,19 +74,19 @@ Number_init :: proc(self: ^Number) -> ^Number { return msgSend(^Number, self, "init") } -@(objc_type=Number, objc_class_name="numberWithI8") Number_numberWithI8 :: proc(value: i8) -> ^Number { return msgSend(^Number, Number, "numberWithChar:", value) } -@(objc_type=Number, objc_class_name="numberWithU8") Number_numberWithU8 :: proc(value: u8) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedChar:", value) } -@(objc_type=Number, objc_class_name="numberWithI16") Number_numberWithI16 :: proc(value: i16) -> ^Number { return msgSend(^Number, Number, "numberWithShort:", value) } -@(objc_type=Number, objc_class_name="numberWithU16") Number_numberWithU16 :: proc(value: u16) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedShort:", value) } -@(objc_type=Number, objc_class_name="numberWithI32") Number_numberWithI32 :: proc(value: i32) -> ^Number { return msgSend(^Number, Number, "numberWithInt:", value) } -@(objc_type=Number, objc_class_name="numberWithU32") Number_numberWithU32 :: proc(value: u32) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedInt:", value) } -@(objc_type=Number, objc_class_name="numberWithInt") Number_numberWithInt :: proc(value: int) -> ^Number { return msgSend(^Number, Number, "numberWithLong:", value) } -@(objc_type=Number, objc_class_name="numberWithUint") Number_numberWithUint :: proc(value: uint) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLong:", value) } -@(objc_type=Number, objc_class_name="numberWithU64") Number_numberWithU64 :: proc(value: u64) -> ^Number { return msgSend(^Number, Number, "numberWithLongLong:", value) } -@(objc_type=Number, objc_class_name="numberWithI64") Number_numberWithI64 :: proc(value: i64) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLongLong:", value) } -@(objc_type=Number, objc_class_name="numberWithF32") Number_numberWithF32 :: proc(value: f32) -> ^Number { return msgSend(^Number, Number, "numberWithFloat:", value) } -@(objc_type=Number, objc_class_name="numberWithF64") Number_numberWithF64 :: proc(value: f64) -> ^Number { return msgSend(^Number, Number, "numberWithDouble:", value) } -@(objc_type=Number, objc_class_name="numberWithBool") Number_numberWithBool :: proc(value: BOOL) -> ^Number { return msgSend(^Number, Number, "numberWithBool:", value) } +@(objc_type=Number, objc_name="numberWithI8", objc_is_class_method=true) Number_numberWithI8 :: proc(value: i8) -> ^Number { return msgSend(^Number, Number, "numberWithChar:", value) } +@(objc_type=Number, objc_name="numberWithU8", objc_is_class_method=true) Number_numberWithU8 :: proc(value: u8) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedChar:", value) } +@(objc_type=Number, objc_name="numberWithI16", objc_is_class_method=true) Number_numberWithI16 :: proc(value: i16) -> ^Number { return msgSend(^Number, Number, "numberWithShort:", value) } +@(objc_type=Number, objc_name="numberWithU16", objc_is_class_method=true) Number_numberWithU16 :: proc(value: u16) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedShort:", value) } +@(objc_type=Number, objc_name="numberWithI32", objc_is_class_method=true) Number_numberWithI32 :: proc(value: i32) -> ^Number { return msgSend(^Number, Number, "numberWithInt:", value) } +@(objc_type=Number, objc_name="numberWithU32", objc_is_class_method=true) Number_numberWithU32 :: proc(value: u32) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedInt:", value) } +@(objc_type=Number, objc_name="numberWithInt", objc_is_class_method=true) Number_numberWithInt :: proc(value: int) -> ^Number { return msgSend(^Number, Number, "numberWithLong:", value) } +@(objc_type=Number, objc_name="numberWithUint", objc_is_class_method=true) Number_numberWithUint :: proc(value: uint) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLong:", value) } +@(objc_type=Number, objc_name="numberWithU64", objc_is_class_method=true) Number_numberWithU64 :: proc(value: u64) -> ^Number { return msgSend(^Number, Number, "numberWithLongLong:", value) } +@(objc_type=Number, objc_name="numberWithI64", objc_is_class_method=true) Number_numberWithI64 :: proc(value: i64) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLongLong:", value) } +@(objc_type=Number, objc_name="numberWithF32", objc_is_class_method=true) Number_numberWithF32 :: proc(value: f32) -> ^Number { return msgSend(^Number, Number, "numberWithFloat:", value) } +@(objc_type=Number, objc_name="numberWithF64", objc_is_class_method=true) Number_numberWithF64 :: proc(value: f64) -> ^Number { return msgSend(^Number, Number, "numberWithDouble:", value) } +@(objc_type=Number, objc_name="numberWithBool", objc_is_class_method=true) Number_numberWithBool :: proc(value: BOOL) -> ^Number { return msgSend(^Number, Number, "numberWithBool:", value) } Number_number :: proc{ Number_numberWithI8, diff --git a/core/sys/darwin/Foundation/NSString.odin b/core/sys/darwin/Foundation/NSString.odin index 06dbc27a3..66442383a 100644 --- a/core/sys/darwin/Foundation/NSString.odin +++ b/core/sys/darwin/Foundation/NSString.odin @@ -59,7 +59,7 @@ MakeConstantString :: proc "c" (#const c: cstring) -> ^String { } -@(objc_type=String, objc_class_name="alloc") +@(objc_type=String, objc_name="alloc", objc_is_class_method=true) String_alloc :: proc() -> ^String { return msgSend(^String, String, "alloc") } diff --git a/core/sys/darwin/Foundation/NSURL.odin b/core/sys/darwin/Foundation/NSURL.odin index 42edf91c0..9813b6e59 100644 --- a/core/sys/darwin/Foundation/NSURL.odin +++ b/core/sys/darwin/Foundation/NSURL.odin @@ -4,7 +4,7 @@ package objc_Foundation URL :: struct{using _: Copying(URL)} -@(objc_type=URL, objc_class_name="alloc") +@(objc_type=URL, objc_name="alloc", objc_is_class_method=true) URL_alloc :: proc() -> ^URL { return msgSend(^URL, URL, "alloc") } diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 7472fa37b..2686ce2ae 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -24,7 +24,7 @@ Methods: @(objc_class="MTLAccelerationStructureBoundingBoxGeometryDescriptor") AccelerationStructureBoundingBoxGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureBoundingBoxGeometryDescriptor), using _: AccelerationStructureDescriptor } -@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_class_name="alloc") +@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="alloc", objc_is_class_method=true) AccelerationStructureBoundingBoxGeometryDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureBoundingBoxGeometryDescriptor { return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, AccelerationStructureBoundingBoxGeometryDescriptor, "alloc") } @@ -48,7 +48,7 @@ AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxCount :: #force_in AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxStride :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "boundingBoxStride") } -@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_class_name="descriptor") +@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="descriptor", objc_is_class_method=true) AccelerationStructureBoundingBoxGeometryDescriptor_descriptor :: #force_inline proc() -> ^AccelerationStructureBoundingBoxGeometryDescriptor { return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, AccelerationStructureBoundingBoxGeometryDescriptor, "descriptor") } @@ -88,31 +88,31 @@ Methods: @(objc_class="MTLMotionKeyframeData") MotionKeyframeData :: struct { using _: NS.Object } -@(objc_type=MotionKeyframeData, objc_class_name="alloc") +@(objc_type=MotionKeyframeData, objc_name="alloc", objc_is_class_method=true) MotionKeyframeData_alloc :: #force_inline proc() -> ^MotionKeyframeData { return msgSend(^MotionKeyframeData, MotionKeyframeData, "alloc") } -@(objc_type=MotionKeyframeData, objc_class_name="data") +@(objc_type=MotionKeyframeData, objc_name="data", objc_is_class_method=true) MotionKeyframeData_data :: #force_inline proc() -> ^MotionKeyframeData { return msgSend(^MotionKeyframeData, MotionKeyframeData, "data") } -@(objc_type=MotionKeyframeData, objc_class_name="init") +@(objc_type=MotionKeyframeData, objc_name="init", objc_is_class_method=true) MotionKeyframeData_init :: #force_inline proc(self: ^MotionKeyframeData) -> ^MotionKeyframeData { return msgSend(^MotionKeyframeData, self, "init") } -@(objc_type=MotionKeyframeData, objc_class_name="buffer") +@(objc_type=MotionKeyframeData, objc_name="buffer", objc_is_class_method=true) MotionKeyframeData_buffer :: #force_inline proc(self: ^MotionKeyframeData) -> ^Buffer { return msgSend(^Buffer, self, "buffer") } -@(objc_type=MotionKeyframeData, objc_class_name="setBuffer") +@(objc_type=MotionKeyframeData, objc_name="setBuffer", objc_is_class_method=true) MotionKeyframeData_setBuffer :: #force_inline proc(self: ^MotionKeyframeData, buffer: ^Buffer) { msgSend(nil, self, "setBuffer:", buffer) } -@(objc_type=MotionKeyframeData, objc_class_name="offset") +@(objc_type=MotionKeyframeData, objc_name="offset", objc_is_class_method=true) MotionKeyframeData_offset :: #force_inline proc(self: ^MotionKeyframeData) -> NS.UInteger { return msgSend(NS.UInteger, self, "offset") } -@(objc_type=MotionKeyframeData, objc_class_name="setOffset") +@(objc_type=MotionKeyframeData, objc_name="setOffset", objc_is_class_method=true) MotionKeyframeData_setOffset :: #force_inline proc(self: ^MotionKeyframeData, offset: NS.UInteger) { msgSend(nil, self, "setOffset:", offset) } @@ -127,7 +127,7 @@ Class: @(objc_class="MTLAccelerationStructureMotionTriangleGeometryDescriptor") AccelerationStructureMotionTriangleGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureMotionTriangleGeometryDescriptor), using _: AccelerationStructureGeometryDescriptor } -@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_class_name="alloc") +@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="alloc", objc_is_class_method=true) AccelerationStructureMotionTriangleGeometryDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureMotionTriangleGeometryDescriptor { return msgSend(^AccelerationStructureMotionTriangleGeometryDescriptor, AccelerationStructureMotionTriangleGeometryDescriptor, "alloc") } @@ -202,7 +202,7 @@ Class: @(objc_class="MTLAccelerationStructureMotionBoundingBoxGeometryDescriptor") AccelerationStructureMotionBoundingBoxGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureMotionBoundingBoxGeometryDescriptor), using _: AccelerationStructureGeometryDescriptor } -@(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_class_name="alloc") +@(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_name="alloc", objc_is_class_method=true) AccelerationStructureMotionBoundingBoxGeometryDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureMotionBoundingBoxGeometryDescriptor { return msgSend(^AccelerationStructureMotionBoundingBoxGeometryDescriptor, AccelerationStructureMotionBoundingBoxGeometryDescriptor, "alloc") } @@ -211,7 +211,7 @@ AccelerationStructureMotionBoundingBoxGeometryDescriptor_init :: #force_inline p return msgSend(^AccelerationStructureMotionBoundingBoxGeometryDescriptor, self, "init") } -@(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_class_name="descriptor") +@(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_name="descriptor", objc_is_class_method=true) AccelerationStructureMotionBoundingBoxGeometryDescriptor_descriptor :: #force_inline proc() -> ^AccelerationStructureMotionBoundingBoxGeometryDescriptor { return msgSend(^AccelerationStructureMotionBoundingBoxGeometryDescriptor, AccelerationStructureMotionBoundingBoxGeometryDescriptor, "descriptor") } @@ -264,7 +264,7 @@ Methods: @(objc_class="MTLAccelerationStructureDescriptor") AccelerationStructureDescriptor :: struct { using _: NS.Copying(AccelerationStructureDescriptor) } -@(objc_type=AccelerationStructureDescriptor, objc_class_name="alloc") +@(objc_type=AccelerationStructureDescriptor, objc_name="alloc", objc_is_class_method=true) AccelerationStructureDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureDescriptor { return msgSend(^AccelerationStructureDescriptor, AccelerationStructureDescriptor, "alloc") } @@ -300,7 +300,7 @@ Methods: @(objc_class="MTLAccelerationStructureGeometryDescriptor") AccelerationStructureGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureGeometryDescriptor) } -@(objc_type=AccelerationStructureGeometryDescriptor, objc_class_name="alloc") +@(objc_type=AccelerationStructureGeometryDescriptor, objc_name="alloc", objc_is_class_method=true) AccelerationStructureGeometryDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureGeometryDescriptor { return msgSend(^AccelerationStructureGeometryDescriptor, AccelerationStructureGeometryDescriptor, "alloc") } @@ -361,7 +361,7 @@ Methods: @(objc_class="MTLAccelerationStructureTriangleGeometryDescriptor") AccelerationStructureTriangleGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureTriangleGeometryDescriptor), using _: AccelerationStructureDescriptor } -@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_class_name="alloc") +@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="alloc", objc_is_class_method=true) AccelerationStructureTriangleGeometryDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureTriangleGeometryDescriptor { return msgSend(^AccelerationStructureTriangleGeometryDescriptor, AccelerationStructureTriangleGeometryDescriptor, "alloc") } @@ -369,7 +369,7 @@ AccelerationStructureTriangleGeometryDescriptor_alloc :: #force_inline proc() -> AccelerationStructureTriangleGeometryDescriptor_init :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^AccelerationStructureTriangleGeometryDescriptor { return msgSend(^AccelerationStructureTriangleGeometryDescriptor, self, "init") } -@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_class_name="descriptor") +@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="descriptor", objc_is_class_method=true) AccelerationStructureTriangleGeometryDescriptor_descriptor :: #force_inline proc() -> ^AccelerationStructureTriangleGeometryDescriptor { return msgSend(^AccelerationStructureTriangleGeometryDescriptor, AccelerationStructureTriangleGeometryDescriptor, "descriptor") } @@ -459,7 +459,7 @@ Methods: @(objc_class="MTLArgument") Argument :: struct { using _: NS.Object } -@(objc_type=Argument, objc_class_name="alloc") +@(objc_type=Argument, objc_name="alloc", objc_is_class_method=true) Argument_alloc :: #force_inline proc() -> ^Argument { return msgSend(^Argument, Argument, "alloc") } @@ -558,7 +558,7 @@ Methods: @(objc_class="MTLArgumentDescriptor") ArgumentDescriptor :: struct { using _: NS.Copying(ArgumentDescriptor) } -@(objc_type=ArgumentDescriptor, objc_class_name="alloc") +@(objc_type=ArgumentDescriptor, objc_name="alloc", objc_is_class_method=true) ArgumentDescriptor_alloc :: #force_inline proc() -> ^ArgumentDescriptor { return msgSend(^ArgumentDescriptor, ArgumentDescriptor, "alloc") } @@ -570,7 +570,7 @@ ArgumentDescriptor_init :: #force_inline proc(self: ^ArgumentDescriptor) -> ^Arg ArgumentDescriptor_access :: #force_inline proc(self: ^ArgumentDescriptor) -> ArgumentAccess { return msgSend(ArgumentAccess, self, "access") } -@(objc_type=ArgumentDescriptor, objc_class_name="argumentDescriptor") +@(objc_type=ArgumentDescriptor, objc_name="argumentDescriptor", objc_is_class_method=true) ArgumentDescriptor_argumentDescriptor :: #force_inline proc() -> ^ArgumentDescriptor { return msgSend(^ArgumentDescriptor, ArgumentDescriptor, "argumentDescriptor") } @@ -640,7 +640,7 @@ Methods: @(objc_class="MTLArrayType") ArrayType :: struct { using _: Type } -@(objc_type=ArrayType, objc_class_name="alloc") +@(objc_type=ArrayType, objc_name="alloc", objc_is_class_method=true) ArrayType_alloc :: #force_inline proc() -> ^ArrayType { return msgSend(^ArrayType, ArrayType, "alloc") } @@ -700,7 +700,7 @@ Methods: @(objc_class="MTLAttribute") Attribute :: struct { using _: NS.Object } -@(objc_type=Attribute, objc_class_name="alloc") +@(objc_type=Attribute, objc_name="alloc", objc_is_class_method=true) Attribute_alloc :: #force_inline proc() -> ^Attribute { return msgSend(^Attribute, Attribute, "alloc") } @@ -752,7 +752,7 @@ Methods: @(objc_class="MTLAttributeDescriptor") AttributeDescriptor :: struct { using _: NS.Copying(AttributeDescriptor) } -@(objc_type=AttributeDescriptor, objc_class_name="alloc") +@(objc_type=AttributeDescriptor, objc_name="alloc", objc_is_class_method=true) AttributeDescriptor_alloc :: #force_inline proc() -> ^AttributeDescriptor { return msgSend(^AttributeDescriptor, AttributeDescriptor, "alloc") } @@ -800,7 +800,7 @@ Methods: @(objc_class="MTLAttributeDescriptorArray") AttributeDescriptorArray :: struct { using _: NS.Object } -@(objc_type=AttributeDescriptorArray, objc_class_name="alloc") +@(objc_type=AttributeDescriptorArray, objc_name="alloc", objc_is_class_method=true) AttributeDescriptorArray_alloc :: #force_inline proc() -> ^AttributeDescriptorArray { return msgSend(^AttributeDescriptorArray, AttributeDescriptorArray, "alloc") } @@ -832,7 +832,7 @@ Methods: @(objc_class="MTLBinaryArchiveDescriptor") BinaryArchiveDescriptor :: struct { using _: NS.Copying(BinaryArchiveDescriptor) } -@(objc_type=BinaryArchiveDescriptor, objc_class_name="alloc") +@(objc_type=BinaryArchiveDescriptor, objc_name="alloc", objc_is_class_method=true) BinaryArchiveDescriptor_alloc :: #force_inline proc() -> ^BinaryArchiveDescriptor { return msgSend(^BinaryArchiveDescriptor, BinaryArchiveDescriptor, "alloc") } @@ -864,7 +864,7 @@ Methods: @(objc_class="MTLBlitPassDescriptor") BlitPassDescriptor :: struct { using _: NS.Copying(BlitPassDescriptor) } -@(objc_type=BlitPassDescriptor, objc_class_name="alloc") +@(objc_type=BlitPassDescriptor, objc_name="alloc", objc_is_class_method=true) BlitPassDescriptor_alloc :: #force_inline proc() -> ^BlitPassDescriptor { return msgSend(^BlitPassDescriptor, BlitPassDescriptor, "alloc") } @@ -872,7 +872,7 @@ BlitPassDescriptor_alloc :: #force_inline proc() -> ^BlitPassDescriptor { BlitPassDescriptor_init :: #force_inline proc(self: ^BlitPassDescriptor) -> ^BlitPassDescriptor { return msgSend(^BlitPassDescriptor, self, "init") } -@(objc_type=BlitPassDescriptor, objc_class_name="blitPassDescriptor") +@(objc_type=BlitPassDescriptor, objc_name="blitPassDescriptor", objc_is_class_method=true) BlitPassDescriptor_blitPassDescriptor :: #force_inline proc() -> ^BlitPassDescriptor { return msgSend(^BlitPassDescriptor, BlitPassDescriptor, "blitPassDescriptor") } @@ -900,7 +900,7 @@ Methods: @(objc_class="MTLBlitPassSampleBufferAttachmentDescriptor") BlitPassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(BlitPassSampleBufferAttachmentDescriptor) } -@(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_class_name="alloc") +@(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) BlitPassSampleBufferAttachmentDescriptor_alloc :: #force_inline proc() -> ^BlitPassSampleBufferAttachmentDescriptor { return msgSend(^BlitPassSampleBufferAttachmentDescriptor, BlitPassSampleBufferAttachmentDescriptor, "alloc") } @@ -948,7 +948,7 @@ Methods: @(objc_class="MTLBlitPassSampleBufferAttachmentDescriptorArray") BlitPassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object } -@(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_class_name="alloc") +@(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_name="alloc", objc_is_class_method=true) BlitPassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^BlitPassSampleBufferAttachmentDescriptorArray { return msgSend(^BlitPassSampleBufferAttachmentDescriptorArray, BlitPassSampleBufferAttachmentDescriptorArray, "alloc") } @@ -984,7 +984,7 @@ Methods: @(objc_class="MTLBufferLayoutDescriptor") BufferLayoutDescriptor :: struct { using _: NS.Copying(BufferLayoutDescriptor) } -@(objc_type=BufferLayoutDescriptor, objc_class_name="alloc") +@(objc_type=BufferLayoutDescriptor, objc_name="alloc", objc_is_class_method=true) BufferLayoutDescriptor_alloc :: #force_inline proc() -> ^BufferLayoutDescriptor { return msgSend(^BufferLayoutDescriptor, BufferLayoutDescriptor, "alloc") } @@ -1032,7 +1032,7 @@ Methods: @(objc_class="MTLBufferLayoutDescriptorArray") BufferLayoutDescriptorArray :: struct { using _: NS.Object } -@(objc_type=BufferLayoutDescriptorArray, objc_class_name="alloc") +@(objc_type=BufferLayoutDescriptorArray, objc_name="alloc", objc_is_class_method=true) BufferLayoutDescriptorArray_alloc :: #force_inline proc() -> ^BufferLayoutDescriptorArray { return msgSend(^BufferLayoutDescriptorArray, BufferLayoutDescriptorArray, "alloc") } @@ -1068,7 +1068,7 @@ Methods: @(objc_class="MTLCaptureDescriptor") CaptureDescriptor :: struct { using _: NS.Copying(CaptureDescriptor) } -@(objc_type=CaptureDescriptor, objc_class_name="alloc") +@(objc_type=CaptureDescriptor, objc_name="alloc", objc_is_class_method=true) CaptureDescriptor_alloc :: #force_inline proc() -> ^CaptureDescriptor { return msgSend(^CaptureDescriptor, CaptureDescriptor, "alloc") } @@ -1126,7 +1126,7 @@ Methods: @(objc_class="MTLCaptureManager") CaptureManager :: struct { using _: NS.Object } -@(objc_type=CaptureManager, objc_class_name="alloc") +@(objc_type=CaptureManager, objc_name="alloc", objc_is_class_method=true) CaptureManager_alloc :: #force_inline proc() -> ^CaptureManager { return msgSend(^CaptureManager, CaptureManager, "alloc") } @@ -1154,7 +1154,7 @@ CaptureManager_newCaptureScopeWithDevice :: #force_inline proc(self: ^CaptureMan CaptureManager_setDefaultCaptureScope :: #force_inline proc(self: ^CaptureManager, defaultCaptureScope: ^CaptureScope) { msgSend(nil, self, "setDefaultCaptureScope:", defaultCaptureScope) } -@(objc_type=CaptureManager, objc_class_name="sharedCaptureManager") +@(objc_type=CaptureManager, objc_name="sharedCaptureManager", objc_is_class_method=true) CaptureManager_sharedCaptureManager :: #force_inline proc() -> ^CaptureManager { return msgSend(^CaptureManager, CaptureManager, "sharedCaptureManager") } @@ -1201,7 +1201,7 @@ Methods: @(objc_class="MTLCommandBufferDescriptor") CommandBufferDescriptor :: struct { using _: NS.Copying(CommandBufferDescriptor) } -@(objc_type=CommandBufferDescriptor, objc_class_name="alloc") +@(objc_type=CommandBufferDescriptor, objc_name="alloc", objc_is_class_method=true) CommandBufferDescriptor_alloc :: #force_inline proc() -> ^CommandBufferDescriptor { return msgSend(^CommandBufferDescriptor, CommandBufferDescriptor, "alloc") } @@ -1253,7 +1253,7 @@ Methods: @(objc_class="MTLCompileOptions") CompileOptions :: struct { using _: NS.Copying(CompileOptions) } -@(objc_type=CompileOptions, objc_class_name="alloc") +@(objc_type=CompileOptions, objc_name="alloc", objc_is_class_method=true) CompileOptions_alloc :: #force_inline proc() -> ^CompileOptions { return msgSend(^CompileOptions, CompileOptions, "alloc") } @@ -1335,7 +1335,7 @@ Methods: @(objc_class="MTLComputePassDescriptor") ComputePassDescriptor :: struct { using _: NS.Copying(ComputePassDescriptor) } -@(objc_type=ComputePassDescriptor, objc_class_name="alloc") +@(objc_type=ComputePassDescriptor, objc_name="alloc", objc_is_class_method=true) ComputePassDescriptor_alloc :: #force_inline proc() -> ^ComputePassDescriptor { return msgSend(^ComputePassDescriptor, ComputePassDescriptor, "alloc") } @@ -1343,7 +1343,7 @@ ComputePassDescriptor_alloc :: #force_inline proc() -> ^ComputePassDescriptor { ComputePassDescriptor_init :: #force_inline proc(self: ^ComputePassDescriptor) -> ^ComputePassDescriptor { return msgSend(^ComputePassDescriptor, self, "init") } -@(objc_type=ComputePassDescriptor, objc_class_name="computePassDescriptor") +@(objc_type=ComputePassDescriptor, objc_name="computePassDescriptor", objc_is_class_method=true) ComputePassDescriptor_computePassDescriptor :: #force_inline proc() -> ^ComputePassDescriptor { return msgSend(^ComputePassDescriptor, ComputePassDescriptor, "computePassDescriptor") } @@ -1379,7 +1379,7 @@ Methods: @(objc_class="MTLComputePassSampleBufferAttachmentDescriptor") ComputePassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(ComputePassSampleBufferAttachmentDescriptor) } -@(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_class_name="alloc") +@(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) ComputePassSampleBufferAttachmentDescriptor_alloc :: #force_inline proc() -> ^ComputePassSampleBufferAttachmentDescriptor { return msgSend(^ComputePassSampleBufferAttachmentDescriptor, ComputePassSampleBufferAttachmentDescriptor, "alloc") } @@ -1427,7 +1427,7 @@ Methods: @(objc_class="MTLComputePassSampleBufferAttachmentDescriptorArray") ComputePassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object } -@(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_class_name="alloc") +@(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_name="alloc", objc_is_class_method=true) ComputePassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^ComputePassSampleBufferAttachmentDescriptorArray { return msgSend(^ComputePassSampleBufferAttachmentDescriptorArray, ComputePassSampleBufferAttachmentDescriptorArray, "alloc") } @@ -1481,7 +1481,7 @@ Methods: @(objc_class="MTLComputePipelineDescriptor") ComputePipelineDescriptor :: struct { using _: NS.Copying(ComputePipelineDescriptor) } -@(objc_type=ComputePipelineDescriptor, objc_class_name="alloc") +@(objc_type=ComputePipelineDescriptor, objc_name="alloc", objc_is_class_method=true) ComputePipelineDescriptor_alloc :: #force_inline proc() -> ^ComputePipelineDescriptor { return msgSend(^ComputePipelineDescriptor, ComputePipelineDescriptor, "alloc") } @@ -1600,7 +1600,7 @@ Methods: @(objc_class="MTLComputePipelineReflection") ComputePipelineReflection :: struct { using _: NS.Object } -@(objc_type=ComputePipelineReflection, objc_class_name="alloc") +@(objc_type=ComputePipelineReflection, objc_name="alloc", objc_is_class_method=true) ComputePipelineReflection_alloc :: #force_inline proc() -> ^ComputePipelineReflection { return msgSend(^ComputePipelineReflection, ComputePipelineReflection, "alloc") } @@ -1634,7 +1634,7 @@ Methods: @(objc_class="MTLCounterSampleBufferDescriptor") CounterSampleBufferDescriptor :: struct { using _: NS.Copying(CounterSampleBufferDescriptor) } -@(objc_type=CounterSampleBufferDescriptor, objc_class_name="alloc") +@(objc_type=CounterSampleBufferDescriptor, objc_name="alloc", objc_is_class_method=true) CounterSampleBufferDescriptor_alloc :: #force_inline proc() -> ^CounterSampleBufferDescriptor { return msgSend(^CounterSampleBufferDescriptor, CounterSampleBufferDescriptor, "alloc") } @@ -1698,7 +1698,7 @@ Methods: @(objc_class="MTLDepthStencilDescriptor") DepthStencilDescriptor :: struct { using _: NS.Copying(DepthStencilDescriptor) } -@(objc_type=DepthStencilDescriptor, objc_class_name="alloc") +@(objc_type=DepthStencilDescriptor, objc_name="alloc", objc_is_class_method=true) DepthStencilDescriptor_alloc :: #force_inline proc() -> ^DepthStencilDescriptor { return msgSend(^DepthStencilDescriptor, DepthStencilDescriptor, "alloc") } @@ -1764,7 +1764,7 @@ Methods: @(objc_class="MTLFunctionConstant") FunctionConstant :: struct { using _: NS.Copying(FunctionConstant) } -@(objc_type=FunctionConstant, objc_class_name="alloc") +@(objc_type=FunctionConstant, objc_name="alloc", objc_is_class_method=true) FunctionConstant_alloc :: #force_inline proc() -> ^FunctionConstant { return msgSend(^FunctionConstant, FunctionConstant, "alloc") } @@ -1806,7 +1806,7 @@ Methods: @(objc_class="MTLFunctionConstantValues") FunctionConstantValues :: struct { using _: NS.Copying(FunctionConstantValues) } -@(objc_type=FunctionConstantValues, objc_class_name="alloc") +@(objc_type=FunctionConstantValues, objc_name="alloc", objc_is_class_method=true) FunctionConstantValues_alloc :: #force_inline proc() -> ^FunctionConstantValues { return msgSend(^FunctionConstantValues, FunctionConstantValues, "alloc") } @@ -1853,7 +1853,7 @@ Methods: @(objc_class="MTLFunctionDescriptor") FunctionDescriptor :: struct { using _: NS.Copying(FunctionDescriptor) } -@(objc_type=FunctionDescriptor, objc_class_name="alloc") +@(objc_type=FunctionDescriptor, objc_name="alloc", objc_is_class_method=true) FunctionDescriptor_alloc :: #force_inline proc() -> ^FunctionDescriptor { return msgSend(^FunctionDescriptor, FunctionDescriptor, "alloc") } @@ -1865,7 +1865,7 @@ FunctionDescriptor_init :: #force_inline proc(self: ^FunctionDescriptor) -> ^Fun FunctionDescriptor_constantValues :: #force_inline proc(self: ^FunctionDescriptor) -> ^FunctionConstantValues { return msgSend(^FunctionConstantValues, self, "constantValues") } -@(objc_type=FunctionDescriptor, objc_class_name="functionDescriptor") +@(objc_type=FunctionDescriptor, objc_name="functionDescriptor", objc_is_class_method=true) FunctionDescriptor_functionDescriptor :: #force_inline proc() -> ^FunctionDescriptor { return msgSend(^FunctionDescriptor, FunctionDescriptor, "functionDescriptor") } @@ -1911,7 +1911,7 @@ Methods: @(objc_class="MTLIntersectionFunctionDescriptor") IntersectionFunctionDescriptor :: struct { using _: NS.Copying(IntersectionFunctionDescriptor) } -@(objc_type=IntersectionFunctionDescriptor, objc_class_name="alloc") +@(objc_type=IntersectionFunctionDescriptor, objc_name="alloc", objc_is_class_method=true) IntersectionFunctionDescriptor_alloc :: #force_inline proc() -> ^IntersectionFunctionDescriptor { return msgSend(^IntersectionFunctionDescriptor, IntersectionFunctionDescriptor, "alloc") } @@ -1945,7 +1945,7 @@ Methods: @(objc_class="MTLHeapDescriptor") HeapDescriptor :: struct { using _: NS.Copying(HeapDescriptor) } -@(objc_type=HeapDescriptor, objc_class_name="alloc") +@(objc_type=HeapDescriptor, objc_name="alloc", objc_is_class_method=true) HeapDescriptor_alloc :: #force_inline proc() -> ^HeapDescriptor { return msgSend(^HeapDescriptor, HeapDescriptor, "alloc") } @@ -2027,7 +2027,7 @@ Methods: @(objc_class="MTLIndirectCommandBufferDescriptor") IndirectCommandBufferDescriptor :: struct { using _: NS.Copying(IndirectCommandBufferDescriptor) } -@(objc_type=IndirectCommandBufferDescriptor, objc_class_name="alloc") +@(objc_type=IndirectCommandBufferDescriptor, objc_name="alloc", objc_is_class_method=true) IndirectCommandBufferDescriptor_alloc :: #force_inline proc() -> ^IndirectCommandBufferDescriptor { return msgSend(^IndirectCommandBufferDescriptor, IndirectCommandBufferDescriptor, "alloc") } @@ -2108,7 +2108,7 @@ Methods: @(objc_class="MTLInstanceAccelerationStructureDescriptor") InstanceAccelerationStructureDescriptor :: struct { using _: NS.Copying(InstanceAccelerationStructureDescriptor), using _: AccelerationStructureDescriptor } -@(objc_type=InstanceAccelerationStructureDescriptor, objc_class_name="alloc") +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="alloc", objc_is_class_method=true) InstanceAccelerationStructureDescriptor_alloc :: #force_inline proc() -> ^InstanceAccelerationStructureDescriptor { return msgSend(^InstanceAccelerationStructureDescriptor, InstanceAccelerationStructureDescriptor, "alloc") } @@ -2116,7 +2116,7 @@ InstanceAccelerationStructureDescriptor_alloc :: #force_inline proc() -> ^Instan InstanceAccelerationStructureDescriptor_init :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> ^InstanceAccelerationStructureDescriptor { return msgSend(^InstanceAccelerationStructureDescriptor, self, "init") } -@(objc_type=InstanceAccelerationStructureDescriptor, objc_class_name="descriptor") +@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="descriptor", objc_is_class_method=true) InstanceAccelerationStructureDescriptor_descriptor :: #force_inline proc() -> ^InstanceAccelerationStructureDescriptor { return msgSend(^InstanceAccelerationStructureDescriptor, InstanceAccelerationStructureDescriptor, "descriptor") } @@ -2217,7 +2217,7 @@ Methods: @(objc_class="MTLIntersectionFunctionTableDescriptor") IntersectionFunctionTableDescriptor :: struct { using _: NS.Copying(IntersectionFunctionTableDescriptor) } -@(objc_type=IntersectionFunctionTableDescriptor, objc_class_name="alloc") +@(objc_type=IntersectionFunctionTableDescriptor, objc_name="alloc", objc_is_class_method=true) IntersectionFunctionTableDescriptor_alloc :: #force_inline proc() -> ^IntersectionFunctionTableDescriptor { return msgSend(^IntersectionFunctionTableDescriptor, IntersectionFunctionTableDescriptor, "alloc") } @@ -2229,7 +2229,7 @@ IntersectionFunctionTableDescriptor_init :: #force_inline proc(self: ^Intersecti IntersectionFunctionTableDescriptor_functionCount :: #force_inline proc(self: ^IntersectionFunctionTableDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "functionCount") } -@(objc_type=IntersectionFunctionTableDescriptor, objc_class_name="intersectionFunctionTableDescriptor") +@(objc_type=IntersectionFunctionTableDescriptor, objc_name="intersectionFunctionTableDescriptor", objc_is_class_method=true) IntersectionFunctionTableDescriptor_intersectionFunctionTableDescriptor :: #force_inline proc() -> ^IntersectionFunctionTableDescriptor { return msgSend(^IntersectionFunctionTableDescriptor, IntersectionFunctionTableDescriptor, "intersectionFunctionTableDescriptor") } @@ -2258,7 +2258,7 @@ Methods: @(objc_class="MTLLinkedFunctions") LinkedFunctions :: struct { using _: NS.Copying(LinkedFunctions) } -@(objc_type=LinkedFunctions, objc_class_name="alloc") +@(objc_type=LinkedFunctions, objc_name="alloc", objc_is_class_method=true) LinkedFunctions_alloc :: #force_inline proc() -> ^LinkedFunctions { return msgSend(^LinkedFunctions, LinkedFunctions, "alloc") } @@ -2278,7 +2278,7 @@ LinkedFunctions_functions :: #force_inline proc(self: ^LinkedFunctions) -> ^NS.A LinkedFunctions_groups :: #force_inline proc(self: ^LinkedFunctions) -> ^NS.Dictionary { return msgSend(^NS.Dictionary, self, "groups") } -@(objc_type=LinkedFunctions, objc_class_name="linkedFunctions") +@(objc_type=LinkedFunctions, objc_name="linkedFunctions", objc_is_class_method=true) LinkedFunctions_linkedFunctions :: #force_inline proc() -> ^LinkedFunctions { return msgSend(^LinkedFunctions, LinkedFunctions, "linkedFunctions") } @@ -2310,7 +2310,7 @@ Methods: @(objc_class="MTLPipelineBufferDescriptor") PipelineBufferDescriptor :: struct { using _: NS.Copying(PipelineBufferDescriptor) } -@(objc_type=PipelineBufferDescriptor, objc_class_name="alloc") +@(objc_type=PipelineBufferDescriptor, objc_name="alloc", objc_is_class_method=true) PipelineBufferDescriptor_alloc :: #force_inline proc() -> ^PipelineBufferDescriptor { return msgSend(^PipelineBufferDescriptor, PipelineBufferDescriptor, "alloc") } @@ -2342,7 +2342,7 @@ Methods: @(objc_class="MTLPipelineBufferDescriptorArray") PipelineBufferDescriptorArray :: struct { using _: NS.Object } -@(objc_type=PipelineBufferDescriptorArray, objc_class_name="alloc") +@(objc_type=PipelineBufferDescriptorArray, objc_name="alloc", objc_is_class_method=true) PipelineBufferDescriptorArray_alloc :: #force_inline proc() -> ^PipelineBufferDescriptorArray { return msgSend(^PipelineBufferDescriptorArray, PipelineBufferDescriptorArray, "alloc") } @@ -2379,7 +2379,7 @@ Methods: @(objc_class="MTLPointerType") PointerType :: struct { using _: Type } -@(objc_type=PointerType, objc_class_name="alloc") +@(objc_type=PointerType, objc_name="alloc", objc_is_class_method=true) PointerType_alloc :: #force_inline proc() -> ^PointerType { return msgSend(^PointerType, PointerType, "alloc") } @@ -2432,7 +2432,7 @@ Methods: @(objc_class="MTLPrimitiveAccelerationStructureDescriptor") PrimitiveAccelerationStructureDescriptor :: struct { using _: NS.Copying(PrimitiveAccelerationStructureDescriptor), using _: AccelerationStructureDescriptor } -@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_class_name="alloc") +@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="alloc", objc_is_class_method=true) PrimitiveAccelerationStructureDescriptor_alloc :: #force_inline proc() -> ^PrimitiveAccelerationStructureDescriptor { return msgSend(^PrimitiveAccelerationStructureDescriptor, PrimitiveAccelerationStructureDescriptor, "alloc") } @@ -2440,7 +2440,7 @@ PrimitiveAccelerationStructureDescriptor_alloc :: #force_inline proc() -> ^Primi PrimitiveAccelerationStructureDescriptor_init :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor) -> ^PrimitiveAccelerationStructureDescriptor { return msgSend(^PrimitiveAccelerationStructureDescriptor, self, "init") } -@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_class_name="descriptor") +@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="descriptor", objc_is_class_method=true) PrimitiveAccelerationStructureDescriptor_descriptor :: #force_inline proc() -> ^PrimitiveAccelerationStructureDescriptor { return msgSend(^PrimitiveAccelerationStructureDescriptor, PrimitiveAccelerationStructureDescriptor, "descriptor") } @@ -2516,7 +2516,7 @@ Methods: @(objc_class="MTLRasterizationRateLayerArray") RasterizationRateLayerArray :: struct { using _: NS.Object } -@(objc_type=RasterizationRateLayerArray, objc_class_name="alloc") +@(objc_type=RasterizationRateLayerArray, objc_name="alloc", objc_is_class_method=true) RasterizationRateLayerArray_alloc :: #force_inline proc() -> ^RasterizationRateLayerArray { return msgSend(^RasterizationRateLayerArray, RasterizationRateLayerArray, "alloc") } @@ -2553,7 +2553,7 @@ Methods: @(objc_class="MTLRasterizationRateLayerDescriptor") RasterizationRateLayerDescriptor :: struct { using _: NS.Copying(RasterizationRateLayerDescriptor) } -@(objc_type=RasterizationRateLayerDescriptor, objc_class_name="alloc") +@(objc_type=RasterizationRateLayerDescriptor, objc_name="alloc", objc_is_class_method=true) RasterizationRateLayerDescriptor_alloc :: #force_inline proc() -> ^RasterizationRateLayerDescriptor { return msgSend(^RasterizationRateLayerDescriptor, RasterizationRateLayerDescriptor, "alloc") } @@ -2614,7 +2614,7 @@ Methods: @(objc_class="MTLRasterizationRateMapDescriptor") RasterizationRateMapDescriptor :: struct { using _: NS.Copying(RasterizationRateMapDescriptor) } -@(objc_type=RasterizationRateMapDescriptor, objc_class_name="alloc") +@(objc_type=RasterizationRateMapDescriptor, objc_name="alloc", objc_is_class_method=true) RasterizationRateMapDescriptor_alloc :: #force_inline proc() -> ^RasterizationRateMapDescriptor { return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "alloc") } @@ -2638,15 +2638,15 @@ RasterizationRateMapDescriptor_layerCount :: #force_inline proc(self: ^Rasteriza RasterizationRateMapDescriptor_layers :: #force_inline proc(self: ^RasterizationRateMapDescriptor) -> ^RasterizationRateLayerArray { return msgSend(^RasterizationRateLayerArray, self, "layers") } -@(objc_type=RasterizationRateMapDescriptor, objc_class_name="rasterizationRateMapDescriptorWithScreenSize") +@(objc_type=RasterizationRateMapDescriptor, objc_name="rasterizationRateMapDescriptorWithScreenSize", objc_is_class_method=true) RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize :: #force_inline proc(screenSize: Size) -> ^RasterizationRateMapDescriptor { return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:", screenSize) } -@(objc_type=RasterizationRateMapDescriptor, objc_class_name="rasterizationRateMapDescriptorWithScreenSizeWithLayer") +@(objc_type=RasterizationRateMapDescriptor, objc_name="rasterizationRateMapDescriptorWithScreenSizeWithLayer", objc_is_class_method=true) RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSizeWithLayer :: #force_inline proc(screenSize: Size, layer: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateMapDescriptor { return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:layer:", screenSize, layer) } -@(objc_type=RasterizationRateMapDescriptor, objc_class_name="rasterizationRateMapDescriptorWithScreenSizeWithLayers") +@(objc_type=RasterizationRateMapDescriptor, objc_name="rasterizationRateMapDescriptorWithScreenSizeWithLayers", objc_is_class_method=true) RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSizeWithLayers :: #force_inline proc(screenSize: Size, layers: []^RasterizationRateLayerDescriptor) -> ^RasterizationRateMapDescriptor { return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:layerCount:layers:", screenSize, NS.UInteger(len(layers)), layers) } @@ -2682,7 +2682,7 @@ Methods: @(objc_class="MTLRasterizationRateSampleArray") RasterizationRateSampleArray :: struct { using _: NS.Object } -@(objc_type=RasterizationRateSampleArray, objc_class_name="alloc") +@(objc_type=RasterizationRateSampleArray, objc_name="alloc", objc_is_class_method=true) RasterizationRateSampleArray_alloc :: #force_inline proc() -> ^RasterizationRateSampleArray { return msgSend(^RasterizationRateSampleArray, RasterizationRateSampleArray, "alloc") } @@ -2734,7 +2734,7 @@ Methods: @(objc_class="MTLRenderPassAttachmentDescriptor") RenderPassAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassAttachmentDescriptor) } -@(objc_type=RenderPassAttachmentDescriptor, objc_class_name="alloc") +@(objc_type=RenderPassAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) RenderPassAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPassAttachmentDescriptor { return msgSend(^RenderPassAttachmentDescriptor, RenderPassAttachmentDescriptor, "alloc") } @@ -2846,7 +2846,7 @@ Methods: @(objc_class="MTLRenderPassColorAttachmentDescriptor") RenderPassColorAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassColorAttachmentDescriptor), using _: RenderPassAttachmentDescriptor } -@(objc_type=RenderPassColorAttachmentDescriptor, objc_class_name="alloc") +@(objc_type=RenderPassColorAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) RenderPassColorAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPassColorAttachmentDescriptor { return msgSend(^RenderPassColorAttachmentDescriptor, RenderPassColorAttachmentDescriptor, "alloc") } @@ -2878,7 +2878,7 @@ Methods: @(objc_class="MTLRenderPassColorAttachmentDescriptorArray") RenderPassColorAttachmentDescriptorArray :: struct { using _: NS.Object } -@(objc_type=RenderPassColorAttachmentDescriptorArray, objc_class_name="alloc") +@(objc_type=RenderPassColorAttachmentDescriptorArray, objc_name="alloc", objc_is_class_method=true) RenderPassColorAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^RenderPassColorAttachmentDescriptorArray { return msgSend(^RenderPassColorAttachmentDescriptorArray, RenderPassColorAttachmentDescriptorArray, "alloc") } @@ -2912,7 +2912,7 @@ Methods: @(objc_class="MTLRenderPassDepthAttachmentDescriptor") RenderPassDepthAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassDepthAttachmentDescriptor), using _: RenderPassAttachmentDescriptor } -@(objc_type=RenderPassDepthAttachmentDescriptor, objc_class_name="alloc") +@(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) RenderPassDepthAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPassDepthAttachmentDescriptor { return msgSend(^RenderPassDepthAttachmentDescriptor, RenderPassDepthAttachmentDescriptor, "alloc") } @@ -2979,7 +2979,7 @@ Methods: @(objc_class="MTLRenderPassDescriptor") RenderPassDescriptor :: struct { using _: NS.Copying(RenderPassDescriptor), using _: AccelerationStructureDescriptor } -@(objc_type=RenderPassDescriptor, objc_class_name="alloc") +@(objc_type=RenderPassDescriptor, objc_name="alloc", objc_is_class_method=true) RenderPassDescriptor_alloc :: #force_inline proc() -> ^RenderPassDescriptor { return msgSend(^RenderPassDescriptor, RenderPassDescriptor, "alloc") } @@ -3011,7 +3011,7 @@ RenderPassDescriptor_imageblockSampleLength :: #force_inline proc(self: ^RenderP RenderPassDescriptor_rasterizationRateMap :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RasterizationRateMap { return msgSend(^RasterizationRateMap, self, "rasterizationRateMap") } -@(objc_type=RenderPassDescriptor, objc_class_name="renderPassDescriptor") +@(objc_type=RenderPassDescriptor, objc_name="renderPassDescriptor", objc_is_class_method=true) RenderPassDescriptor_renderPassDescriptor :: #force_inline proc() -> ^RenderPassDescriptor { return msgSend(^RenderPassDescriptor, RenderPassDescriptor, "renderPassDescriptor") } @@ -3127,7 +3127,7 @@ Methods: @(objc_class="MTLRenderPassSampleBufferAttachmentDescriptor") RenderPassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassSampleBufferAttachmentDescriptor) } -@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_class_name="alloc") +@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) RenderPassSampleBufferAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPassSampleBufferAttachmentDescriptor { return msgSend(^RenderPassSampleBufferAttachmentDescriptor, RenderPassSampleBufferAttachmentDescriptor, "alloc") } @@ -3191,7 +3191,7 @@ Methods: @(objc_class="MTLRenderPassSampleBufferAttachmentDescriptorArray") RenderPassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object } -@(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_class_name="alloc") +@(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_name="alloc", objc_is_class_method=true) RenderPassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^RenderPassSampleBufferAttachmentDescriptorArray { return msgSend(^RenderPassSampleBufferAttachmentDescriptorArray, RenderPassSampleBufferAttachmentDescriptorArray, "alloc") } @@ -3225,7 +3225,7 @@ Methods: @(objc_class="MTLRenderPassStencilAttachmentDescriptor") RenderPassStencilAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassStencilAttachmentDescriptor) } -@(objc_type=RenderPassStencilAttachmentDescriptor, objc_class_name="alloc") +@(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) RenderPassStencilAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPassStencilAttachmentDescriptor { return msgSend(^RenderPassStencilAttachmentDescriptor, RenderPassStencilAttachmentDescriptor, "alloc") } @@ -3281,7 +3281,7 @@ Methods: @(objc_class="MTLRenderPipelineColorAttachmentDescriptor") RenderPipelineColorAttachmentDescriptor :: struct { using _: NS.Copying(RenderPipelineColorAttachmentDescriptor), using _: RenderPassAttachmentDescriptor } -@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_class_name="alloc") +@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) RenderPipelineColorAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPipelineColorAttachmentDescriptor { return msgSend(^RenderPipelineColorAttachmentDescriptor, RenderPipelineColorAttachmentDescriptor, "alloc") } @@ -3377,7 +3377,7 @@ Methods: @(objc_class="MTLRenderPipelineColorAttachmentDescriptorArray") RenderPipelineColorAttachmentDescriptorArray :: struct { using _: NS.Object } -@(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_class_name="alloc") +@(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_name="alloc", objc_is_class_method=true) RenderPipelineColorAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^RenderPipelineColorAttachmentDescriptorArray { return msgSend(^RenderPipelineColorAttachmentDescriptorArray, RenderPipelineColorAttachmentDescriptorArray, "alloc") } @@ -3455,7 +3455,7 @@ Methods: @(objc_class="MTLRenderPipelineDescriptor") RenderPipelineDescriptor :: struct { using _: NS.Copying(RenderPipelineDescriptor) } -@(objc_type=RenderPipelineDescriptor, objc_class_name="alloc") +@(objc_type=RenderPipelineDescriptor, objc_name="alloc", objc_is_class_method=true) RenderPipelineDescriptor_alloc :: #force_inline proc() -> ^RenderPipelineDescriptor { return msgSend(^RenderPipelineDescriptor, RenderPipelineDescriptor, "alloc") } @@ -3672,7 +3672,7 @@ Methods: @(objc_class="MTLRenderPipelineReflection") RenderPipelineReflection :: struct { using _: NS.Object } -@(objc_type=RenderPipelineReflection, objc_class_name="alloc") +@(objc_type=RenderPipelineReflection, objc_name="alloc", objc_is_class_method=true) RenderPipelineReflection_alloc :: #force_inline proc() -> ^RenderPipelineReflection { return msgSend(^RenderPipelineReflection, RenderPipelineReflection, "alloc") } @@ -3708,7 +3708,7 @@ Methods: @(objc_class="MTLResourceStatePassDescriptor") ResourceStatePassDescriptor :: struct { using _: NS.Copying(ResourceStatePassDescriptor) } -@(objc_type=ResourceStatePassDescriptor, objc_class_name="alloc") +@(objc_type=ResourceStatePassDescriptor, objc_name="alloc", objc_is_class_method=true) ResourceStatePassDescriptor_alloc :: #force_inline proc() -> ^ResourceStatePassDescriptor { return msgSend(^ResourceStatePassDescriptor, ResourceStatePassDescriptor, "alloc") } @@ -3716,7 +3716,7 @@ ResourceStatePassDescriptor_alloc :: #force_inline proc() -> ^ResourceStatePassD ResourceStatePassDescriptor_init :: #force_inline proc(self: ^ResourceStatePassDescriptor) -> ^ResourceStatePassDescriptor { return msgSend(^ResourceStatePassDescriptor, self, "init") } -@(objc_type=ResourceStatePassDescriptor, objc_class_name="resourceStatePassDescriptor") +@(objc_type=ResourceStatePassDescriptor, objc_name="resourceStatePassDescriptor", objc_is_class_method=true) ResourceStatePassDescriptor_resourceStatePassDescriptor :: #force_inline proc() -> ^ResourceStatePassDescriptor { return msgSend(^ResourceStatePassDescriptor, ResourceStatePassDescriptor, "resourceStatePassDescriptor") } @@ -3744,7 +3744,7 @@ Methods: @(objc_class="MTLResourceStatePassSampleBufferAttachmentDescriptor") ResourceStatePassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(ResourceStatePassSampleBufferAttachmentDescriptor) } -@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_class_name="alloc") +@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) ResourceStatePassSampleBufferAttachmentDescriptor_alloc :: #force_inline proc() -> ^ResourceStatePassSampleBufferAttachmentDescriptor { return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, ResourceStatePassSampleBufferAttachmentDescriptor, "alloc") } @@ -3792,7 +3792,7 @@ Methods: @(objc_class="MTLResourceStatePassSampleBufferAttachmentDescriptorArray") ResourceStatePassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object } -@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_class_name="alloc") +@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_name="alloc", objc_is_class_method=true) ResourceStatePassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray { return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptorArray, ResourceStatePassSampleBufferAttachmentDescriptorArray, "alloc") } @@ -3852,7 +3852,7 @@ Methods: @(objc_class="MTLSamplerDescriptor") SamplerDescriptor :: struct { using _: NS.Copying(SamplerDescriptor) } -@(objc_type=SamplerDescriptor, objc_class_name="alloc") +@(objc_type=SamplerDescriptor, objc_name="alloc", objc_is_class_method=true) SamplerDescriptor_alloc :: #force_inline proc() -> ^SamplerDescriptor { return msgSend(^SamplerDescriptor, SamplerDescriptor, "alloc") } @@ -3995,7 +3995,7 @@ Methods: @(objc_class="MTLSharedEventHandle") SharedEventHandle :: struct { using _: NS.Object } -@(objc_type=SharedEventHandle, objc_class_name="alloc") +@(objc_type=SharedEventHandle, objc_name="alloc", objc_is_class_method=true) SharedEventHandle_alloc :: #force_inline proc() -> ^SharedEventHandle { return msgSend(^SharedEventHandle, SharedEventHandle, "alloc") } @@ -4023,7 +4023,7 @@ Methods: @(objc_class="MTLSharedEventListener") SharedEventListener :: struct { using _: NS.Object } -@(objc_type=SharedEventListener, objc_class_name="alloc") +@(objc_type=SharedEventListener, objc_name="alloc", objc_is_class_method=true) SharedEventListener_alloc :: #force_inline proc() -> ^SharedEventListener { return msgSend(^SharedEventListener, SharedEventListener, "alloc") } @@ -4055,7 +4055,7 @@ Methods: @(objc_class="MTLSharedTextureHandle") SharedTextureHandle :: struct { using _: NS.Object } -@(objc_type=SharedTextureHandle, objc_class_name="alloc") +@(objc_type=SharedTextureHandle, objc_name="alloc", objc_is_class_method=true) SharedTextureHandle_alloc :: #force_inline proc() -> ^SharedTextureHandle { return msgSend(^SharedTextureHandle, SharedTextureHandle, "alloc") } @@ -4093,7 +4093,7 @@ Methods: @(objc_class="MTLStageInputOutputDescriptor") StageInputOutputDescriptor :: struct { using _: NS.Copying(StageInputOutputDescriptor) } -@(objc_type=StageInputOutputDescriptor, objc_class_name="alloc") +@(objc_type=StageInputOutputDescriptor, objc_name="alloc", objc_is_class_method=true) StageInputOutputDescriptor_alloc :: #force_inline proc() -> ^StageInputOutputDescriptor { return msgSend(^StageInputOutputDescriptor, StageInputOutputDescriptor, "alloc") } @@ -4129,7 +4129,7 @@ StageInputOutputDescriptor_setIndexBufferIndex :: #force_inline proc(self: ^Stag StageInputOutputDescriptor_setIndexType :: #force_inline proc(self: ^StageInputOutputDescriptor, indexType: IndexType) { msgSend(nil, self, "setIndexType:", indexType) } -@(objc_type=StageInputOutputDescriptor, objc_class_name="stageInputOutputDescriptor") +@(objc_type=StageInputOutputDescriptor, objc_name="stageInputOutputDescriptor", objc_is_class_method=true) StageInputOutputDescriptor_stageInputOutputDescriptor :: #force_inline proc() -> ^StageInputOutputDescriptor { return msgSend(^StageInputOutputDescriptor, StageInputOutputDescriptor, "stageInputOutputDescriptor") } @@ -4159,7 +4159,7 @@ Methods: @(objc_class="MTLStencilDescriptor") StencilDescriptor :: struct { using _: NS.Copying(StencilDescriptor) } -@(objc_type=StencilDescriptor, objc_class_name="alloc") +@(objc_type=StencilDescriptor, objc_name="alloc", objc_is_class_method=true) StencilDescriptor_alloc :: #force_inline proc() -> ^StencilDescriptor { return msgSend(^StencilDescriptor, StencilDescriptor, "alloc") } @@ -4237,7 +4237,7 @@ Methods: @(objc_class="MTLStructMember") StructMember :: struct { using _: NS.Object } -@(objc_type=StructMember, objc_class_name="alloc") +@(objc_type=StructMember, objc_name="alloc", objc_is_class_method=true) StructMember_alloc :: #force_inline proc() -> ^StructMember { return msgSend(^StructMember, StructMember, "alloc") } @@ -4293,7 +4293,7 @@ Methods: @(objc_class="MTLStructType") StructType :: struct { using _: Type } -@(objc_type=StructType, objc_class_name="alloc") +@(objc_type=StructType, objc_name="alloc", objc_is_class_method=true) StructType_alloc :: #force_inline proc() -> ^StructType { return msgSend(^StructType, StructType, "alloc") } @@ -4356,7 +4356,7 @@ Methods: @(objc_class="MTLTextureDescriptor") TextureDescriptor :: struct { using _: NS.Copying(TextureDescriptor) } -@(objc_type=TextureDescriptor, objc_class_name="alloc") +@(objc_type=TextureDescriptor, objc_name="alloc", objc_is_class_method=true) TextureDescriptor_alloc :: #force_inline proc() -> ^TextureDescriptor { return msgSend(^TextureDescriptor, TextureDescriptor, "alloc") } @@ -4472,15 +4472,15 @@ TextureDescriptor_storageMode :: #force_inline proc(self: ^TextureDescriptor) -> TextureDescriptor_swizzle :: #force_inline proc(self: ^TextureDescriptor) -> TextureSwizzleChannels { return msgSend(TextureSwizzleChannels, self, "swizzle") } -@(objc_type=TextureDescriptor, objc_class_name="texture2DDescriptor") +@(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 { return msgSend(^TextureDescriptor, TextureDescriptor, "texture2DDescriptorWithPixelFormat:width:height:mipmapped:", pixelFormat, width, height, mipmapped) } -@(objc_type=TextureDescriptor, objc_class_name="textureBufferDescriptor") +@(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 { return msgSend(^TextureDescriptor, TextureDescriptor, "textureBufferDescriptorWithPixelFormat:width:resourceOptions:usage:", pixelFormat, width, resourceOptions, usage) } -@(objc_type=TextureDescriptor, objc_class_name="textureCubeDescriptor") +@(objc_type=TextureDescriptor, objc_name="textureCubeDescriptor", objc_is_class_method=true) TextureDescriptor_textureCubeDescriptor :: #force_inline proc(pixelFormat: PixelFormat, size: NS.UInteger, mipmapped: BOOL) -> ^TextureDescriptor { return msgSend(^TextureDescriptor, TextureDescriptor, "textureCubeDescriptorWithPixelFormat:size:mipmapped:", pixelFormat, size, mipmapped) } @@ -4514,7 +4514,7 @@ Methods: @(objc_class="MTLTextureReferenceType") TextureReferenceType :: struct { using _: Type } -@(objc_type=TextureReferenceType, objc_class_name="alloc") +@(objc_type=TextureReferenceType, objc_name="alloc", objc_is_class_method=true) TextureReferenceType_alloc :: #force_inline proc() -> ^TextureReferenceType { return msgSend(^TextureReferenceType, TextureReferenceType, "alloc") } @@ -4554,7 +4554,7 @@ Methods: @(objc_class="MTLTileRenderPipelineColorAttachmentDescriptor") TileRenderPipelineColorAttachmentDescriptor :: struct { using _: NS.Copying(TileRenderPipelineColorAttachmentDescriptor) } -@(objc_type=TileRenderPipelineColorAttachmentDescriptor, objc_class_name="alloc") +@(objc_type=TileRenderPipelineColorAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) TileRenderPipelineColorAttachmentDescriptor_alloc :: #force_inline proc() -> ^TileRenderPipelineColorAttachmentDescriptor { return msgSend(^TileRenderPipelineColorAttachmentDescriptor, TileRenderPipelineColorAttachmentDescriptor, "alloc") } @@ -4586,7 +4586,7 @@ Methods: @(objc_class="MTLTileRenderPipelineColorAttachmentDescriptorArray") TileRenderPipelineColorAttachmentDescriptorArray :: struct { using _: NS.Object } -@(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_class_name="alloc") +@(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_name="alloc", objc_is_class_method=true) TileRenderPipelineColorAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^TileRenderPipelineColorAttachmentDescriptorArray { return msgSend(^TileRenderPipelineColorAttachmentDescriptorArray, TileRenderPipelineColorAttachmentDescriptorArray, "alloc") } @@ -4631,7 +4631,7 @@ Methods: @(objc_class="MTLTileRenderPipelineDescriptor") TileRenderPipelineDescriptor :: struct { using _: NS.Copying(TileRenderPipelineDescriptor) } -@(objc_type=TileRenderPipelineDescriptor, objc_class_name="alloc") +@(objc_type=TileRenderPipelineDescriptor, objc_name="alloc", objc_is_class_method=true) TileRenderPipelineDescriptor_alloc :: #force_inline proc() -> ^TileRenderPipelineDescriptor { return msgSend(^TileRenderPipelineDescriptor, TileRenderPipelineDescriptor, "alloc") } @@ -4714,7 +4714,7 @@ Methods: @(objc_class="MTLType") Type :: struct { using _: NS.Object } -@(objc_type=Type, objc_class_name="alloc") +@(objc_type=Type, objc_name="alloc", objc_is_class_method=true) Type_alloc :: #force_inline proc() -> ^Type { return msgSend(^Type, Type, "alloc") } @@ -4746,7 +4746,7 @@ Methods: @(objc_class="MTLVertexAttribute") VertexAttribute :: struct { using _: NS.Object } -@(objc_type=VertexAttribute, objc_class_name="alloc") +@(objc_type=VertexAttribute, objc_name="alloc", objc_is_class_method=true) VertexAttribute_alloc :: #force_inline proc() -> ^VertexAttribute { return msgSend(^VertexAttribute, VertexAttribute, "alloc") } @@ -4798,7 +4798,7 @@ Methods: @(objc_class="MTLVertexAttributeDescriptor") VertexAttributeDescriptor :: struct { using _: NS.Copying(VertexAttributeDescriptor) } -@(objc_type=VertexAttributeDescriptor, objc_class_name="alloc") +@(objc_type=VertexAttributeDescriptor, objc_name="alloc", objc_is_class_method=true) VertexAttributeDescriptor_alloc :: #force_inline proc() -> ^VertexAttributeDescriptor { return msgSend(^VertexAttributeDescriptor, VertexAttributeDescriptor, "alloc") } @@ -4846,7 +4846,7 @@ Methods: @(objc_class="MTLVertexAttributeDescriptorArray") VertexAttributeDescriptorArray :: struct { using _: NS.Object } -@(objc_type=VertexAttributeDescriptorArray, objc_class_name="alloc") +@(objc_type=VertexAttributeDescriptorArray, objc_name="alloc", objc_is_class_method=true) VertexAttributeDescriptorArray_alloc :: #force_inline proc() -> ^VertexAttributeDescriptorArray { return msgSend(^VertexAttributeDescriptorArray, VertexAttributeDescriptorArray, "alloc") } @@ -4882,7 +4882,7 @@ Methods: @(objc_class="MTLVertexBufferLayoutDescriptor") VertexBufferLayoutDescriptor :: struct { using _: NS.Copying(VertexBufferLayoutDescriptor) } -@(objc_type=VertexBufferLayoutDescriptor, objc_class_name="alloc") +@(objc_type=VertexBufferLayoutDescriptor, objc_name="alloc", objc_is_class_method=true) VertexBufferLayoutDescriptor_alloc :: #force_inline proc() -> ^VertexBufferLayoutDescriptor { return msgSend(^VertexBufferLayoutDescriptor, VertexBufferLayoutDescriptor, "alloc") } @@ -4930,7 +4930,7 @@ Methods: @(objc_class="MTLVertexBufferLayoutDescriptorArray") VertexBufferLayoutDescriptorArray :: struct { using _: NS.Object } -@(objc_type=VertexBufferLayoutDescriptorArray, objc_class_name="alloc") +@(objc_type=VertexBufferLayoutDescriptorArray, objc_name="alloc", objc_is_class_method=true) VertexBufferLayoutDescriptorArray_alloc :: #force_inline proc() -> ^VertexBufferLayoutDescriptorArray { return msgSend(^VertexBufferLayoutDescriptorArray, VertexBufferLayoutDescriptorArray, "alloc") } @@ -4964,7 +4964,7 @@ Methods: @(objc_class="MTLVertexDescriptor") VertexDescriptor :: struct { using _: NS.Copying(VertexDescriptor) } -@(objc_type=VertexDescriptor, objc_class_name="alloc") +@(objc_type=VertexDescriptor, objc_name="alloc", objc_is_class_method=true) VertexDescriptor_alloc :: #force_inline proc() -> ^VertexDescriptor { return msgSend(^VertexDescriptor, VertexDescriptor, "alloc") } @@ -4984,7 +4984,7 @@ VertexDescriptor_layouts :: #force_inline proc(self: ^VertexDescriptor) -> ^Vert VertexDescriptor_reset :: #force_inline proc(self: ^VertexDescriptor) { msgSend(nil, self, "reset") } -@(objc_type=VertexDescriptor, objc_class_name="vertexDescriptor") +@(objc_type=VertexDescriptor, objc_name="vertexDescriptor", objc_is_class_method=true) VertexDescriptor_vertexDescriptor :: #force_inline proc() -> ^VertexDescriptor { return msgSend(^VertexDescriptor, VertexDescriptor, "vertexDescriptor") } @@ -5005,7 +5005,7 @@ Methods: @(objc_class="MTLVisibleFunctionTableDescriptor") VisibleFunctionTableDescriptor :: struct { using _: NS.Copying(VisibleFunctionTableDescriptor) } -@(objc_type=VisibleFunctionTableDescriptor, objc_class_name="alloc") +@(objc_type=VisibleFunctionTableDescriptor, objc_name="alloc", objc_is_class_method=true) VisibleFunctionTableDescriptor_alloc :: #force_inline proc() -> ^VisibleFunctionTableDescriptor { return msgSend(^VisibleFunctionTableDescriptor, VisibleFunctionTableDescriptor, "alloc") } @@ -5021,7 +5021,7 @@ VisibleFunctionTableDescriptor_functionCount :: #force_inline proc(self: ^Visibl VisibleFunctionTableDescriptor_setFunctionCount :: #force_inline proc(self: ^VisibleFunctionTableDescriptor, functionCount: NS.UInteger) { msgSend(nil, self, "setFunctionCount:", functionCount) } -@(objc_type=VisibleFunctionTableDescriptor, objc_class_name="visibleFunctionTableDescriptor") +@(objc_type=VisibleFunctionTableDescriptor, objc_name="visibleFunctionTableDescriptor", objc_is_class_method=true) VisibleFunctionTableDescriptor_visibleFunctionTableDescriptor :: #force_inline proc() -> ^VisibleFunctionTableDescriptor { return msgSend(^VisibleFunctionTableDescriptor, VisibleFunctionTableDescriptor, "visibleFunctionTableDescriptor") } @@ -7976,7 +7976,7 @@ Class: @(objc_class="MTLRenderPipelineFunctionsDescriptor") RenderPipelineFunctionsDescriptor :: struct { using _: NS.Copying(RenderPipelineFunctionsDescriptor) } -@(objc_type=RenderPipelineFunctionsDescriptor, objc_class_name="alloc") +@(objc_type=RenderPipelineFunctionsDescriptor, objc_name="alloc", objc_is_class_method=true) RenderPipelineFunctionsDescriptor_alloc :: #force_inline proc() -> ^RenderPipelineFunctionsDescriptor { return msgSend(^RenderPipelineFunctionsDescriptor, RenderPipelineFunctionsDescriptor, "alloc") } diff --git a/core/sys/darwin/QuartzCore/QuartzCore.odin b/core/sys/darwin/QuartzCore/QuartzCore.odin index 0afb8aa37..c35453efc 100644 --- a/core/sys/darwin/QuartzCore/QuartzCore.odin +++ b/core/sys/darwin/QuartzCore/QuartzCore.odin @@ -10,7 +10,7 @@ msgSend :: intrinsics.objc_send @(objc_class="CAMetalLayer") MetalLayer :: struct{ using _: NS.Layer} -@(objc_type=MetalLayer, objc_class_name="layer") +@(objc_type=MetalLayer, objc_name="layer", objc_is_class_method=true) MetalLayer_layer :: proc() -> ^MetalLayer { return msgSend(^MetalLayer, MetalLayer, "layer") } diff --git a/src/check_decl.cpp b/src/check_decl.cpp index 1d30088d6..45d741532 100644 --- a/src/check_decl.cpp +++ b/src/check_decl.cpp @@ -826,15 +826,13 @@ void check_proc_decl(CheckerContext *ctx, Entity *e, DeclInfo *d) { } e->Procedure.optimization_mode = cast(ProcedureOptimizationMode)ac.optimization_mode; - if (ac.objc_name.len || ac.objc_class_name.len || ac.objc_type) { - if (ac.objc_class_name.len && ac.objc_name.len) { - error(e->token, "@(objc_class_name) and @(objc_name) may not be allowed at the same time"); + if (ac.objc_name.len || ac.objc_is_class_method || ac.objc_type) { + if (ac.objc_name.len == 0 && ac.objc_is_class_method) { + error(e->token, "@(objc_name) is required with @(objc_is_class_method)"); } else if (ac.objc_type == nullptr) { - if (ac.objc_name.len) { - error(e->token, "@(objc_name) requires that @(objc_type) to be set"); - } else { - error(e->token, "@(objc_class_name) requires that @(objc_type) to be set"); - } + error(e->token, "@(objc_name) requires that @(objc_type) to be set"); + } else if (ac.objc_name.len == 0 && ac.objc_type) { + error(e->token, "@(objc_name) is required with @(objc_type)"); } else { Type *t = ac.objc_type; if (t->kind == Type_Named) { @@ -843,7 +841,7 @@ void check_proc_decl(CheckerContext *ctx, Entity *e, DeclInfo *d) { GB_ASSERT(tn->kind == Entity_TypeName); if (tn->scope != e->scope) { - error(e->token, "@(objc_name) and @(objc_class_name) attributes may only be applied to procedures and types within the same scope"); + error(e->token, "@(objc_name) attribute may only be applied to procedures and types within the same scope"); } else { mutex_lock(&global_type_name_objc_metadata_mutex); defer (mutex_unlock(&global_type_name_objc_metadata_mutex)); @@ -855,7 +853,7 @@ void check_proc_decl(CheckerContext *ctx, Entity *e, DeclInfo *d) { mutex_lock(md->mutex); defer (mutex_unlock(md->mutex)); - if (ac.objc_name.len) { + if (!ac.objc_is_class_method) { bool ok = true; for (TypeNameObjCMetadataEntry const &entry : md->value_entries) { if (entry.name == ac.objc_name) { @@ -870,14 +868,14 @@ void check_proc_decl(CheckerContext *ctx, Entity *e, DeclInfo *d) { } else { bool ok = true; for (TypeNameObjCMetadataEntry const &entry : md->type_entries) { - if (entry.name == ac.objc_class_name) { - error(e->token, "Previous declaration of @(objc_class_name=\"%.*s\")", LIT(ac.objc_class_name)); + if (entry.name == ac.objc_name) { + error(e->token, "Previous declaration of @(objc_name=\"%.*s\")", LIT(ac.objc_name)); ok = false; break; } } if (ok) { - array_add(&md->type_entries, TypeNameObjCMetadataEntry{ac.objc_class_name, e}); + array_add(&md->type_entries, TypeNameObjCMetadataEntry{ac.objc_name, e}); } } } diff --git a/src/checker.cpp b/src/checker.cpp index 0dd36987e..dac4dd79f 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -3059,16 +3059,12 @@ DECL_ATTRIBUTE_PROC(proc_decl_attribute) { error(elem, "Expected a string value for '%.*s'", LIT(name)); } return true; - } else if (name == "objc_class_name") { + } else if (name == "objc_is_class_method") { ExactValue ev = check_decl_attribute_value(c, value); - if (ev.kind == ExactValue_String) { - if (string_is_valid_identifier(ev.value_string)) { - ac->objc_class_name = ev.value_string; - } else { - error(elem, "Invalid identifier for '%.*s', got '%.*s'", LIT(name), LIT(ev.value_string)); - } + if (ev.kind == ExactValue_Bool) { + ac->objc_is_class_method = ev.value_bool; } else { - error(elem, "Expected a string value for '%.*s'", LIT(name)); + error(elem, "Expected a boolean value for '%.*s'", LIT(name)); } return true; } else if (name == "objc_type") { diff --git a/src/checker.hpp b/src/checker.hpp index 38c8d32f6..552e6aca7 100644 --- a/src/checker.hpp +++ b/src/checker.hpp @@ -121,7 +121,7 @@ struct AttributeContext { String objc_class; String objc_name; - String objc_class_name; + bool objc_is_class_method; Type * objc_type; }; From 32c7e817450e8f089eec81a147d20b919db088ff Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 18:32:10 +0000 Subject: [PATCH 59/64] Use `objc_allocateClassPair` for `intrinsics.objc_register_class` --- core/runtime/procs_darwin.odin | 1 + src/check_builtin.cpp | 1 + src/llvm_backend_utility.cpp | 8 +++++--- 3 files changed, 7 insertions(+), 3 deletions(-) diff --git a/core/runtime/procs_darwin.odin b/core/runtime/procs_darwin.odin index 79fd777d7..b54a28dcc 100644 --- a/core/runtime/procs_darwin.odin +++ b/core/runtime/procs_darwin.odin @@ -12,6 +12,7 @@ objc_SEL :: ^intrinsics.objc_selector foreign Foundation { objc_lookUpClass :: proc "c" (name: cstring) -> objc_Class --- sel_registerName :: proc "c" (name: cstring) -> objc_SEL --- + objc_allocateClassPair :: proc "c" (superclass: objc_Class, name: cstring, extraBytes: uint) --- objc_msgSend :: proc "c" (self: objc_id, op: objc_SEL, #c_vararg args: ..any) --- objc_msgSend_fpret :: proc "c" (self: objc_id, op: objc_SEL, #c_vararg args: ..any) -> f64 --- diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp index a6b1759f5..c7ada8e03 100644 --- a/src/check_builtin.cpp +++ b/src/check_builtin.cpp @@ -225,6 +225,7 @@ void add_objc_proc_type(CheckerContext *c, Ast *call, Type *return_type, Slice(permanent_allocator(), 1); - args[0] = lb_const_value(m, t_cstring, exact_value_string(name)); - lbValue ptr = lb_emit_runtime_call(p, "objc_lookUpClass", args); + auto args = array_make(permanent_allocator(), 3); + args[0] = lb_const_nil(m, t_objc_Class); + args[1] = lb_const_nil(m, t_objc_Class); + args[2] = lb_const_int(m, t_uint, 0); + lbValue ptr = lb_emit_runtime_call(p, "objc_allocateClassPair", args); lb_addr_store(p, dst, ptr); return lb_addr_load(p, dst); From 753cceea82b99c3dbf0f6adc286469123d5bd076 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 14 Feb 2022 18:34:55 +0000 Subject: [PATCH 60/64] Minor changes to method names on NS.String --- core/sys/darwin/Foundation/NSString.odin | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/core/sys/darwin/Foundation/NSString.odin b/core/sys/darwin/Foundation/NSString.odin index 66442383a..ae1d6d43f 100644 --- a/core/sys/darwin/Foundation/NSString.odin +++ b/core/sys/darwin/Foundation/NSString.odin @@ -100,8 +100,8 @@ String_length :: proc(self: ^String) -> UInteger { return msgSend(UInteger, self, "length") } -@(objc_type=String, objc_name="cStringUsingEncoding") -String_cStringUsingEncoding :: proc(self: ^String, encoding: StringEncoding) -> cstring { +@(objc_type=String, objc_name="cstringUsingEncoding") +String_cstringUsingEncoding :: proc(self: ^String, encoding: StringEncoding) -> cstring { return msgSend(cstring, self, "cStringUsingEncoding:", encoding) } @@ -110,8 +110,8 @@ String_UTF8String :: proc(self: ^String) -> cstring { return msgSend(cstring, self, "UTF8String") } -@(objc_type=String, objc_name="OdinString") -String_OdinString :: proc(self: ^String) -> string { +@(objc_type=String, objc_name="odinString") +String_odinString :: proc(self: ^String) -> string { return string(String_UTF8String(self)) } From 0e5928ff39653d3a1de3e071afbcc1b29f5fe9f7 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 15 Feb 2022 15:16:30 +0000 Subject: [PATCH 61/64] Correct pseudo selector code generation --- src/check_expr.cpp | 6 +++--- src/llvm_backend_expr.cpp | 9 +++++---- 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/src/check_expr.cpp b/src/check_expr.cpp index 6db17a316..7fb0e44f2 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -6396,10 +6396,10 @@ ExprKind check_call_expr(CheckerContext *c, Operand *operand, Ast *call, Ast *pr return builtin_procs[id].kind; } - Entity *e = entity_of_node(operand->expr); + Entity *initial_entity = entity_of_node(operand->expr); - if (e != nullptr && e->kind == Entity_Procedure) { - if (e->Procedure.deferred_procedure.entity != nullptr) { + if (initial_entity != nullptr && initial_entity->kind == Entity_Procedure) { + if (initial_entity->Procedure.deferred_procedure.entity != nullptr) { call->viral_state_flags |= ViralStateFlag_ContainsDeferredProcedure; } } diff --git a/src/llvm_backend_expr.cpp b/src/llvm_backend_expr.cpp index b2f430cd2..844deb43c 100644 --- a/src/llvm_backend_expr.cpp +++ b/src/llvm_backend_expr.cpp @@ -3303,9 +3303,9 @@ lbAddr lb_build_addr(lbProcedure *p, Ast *expr) { case_end; case_ast_node(se, SelectorExpr, expr); - Ast *sel = unparen_expr(se->selector); - if (sel->kind == Ast_Ident) { - String selector = sel->Ident.token.string; + Ast *sel_node = unparen_expr(se->selector); + if (sel_node->kind == Ast_Ident) { + String selector = sel_node->Ident.token.string; TypeAndValue tav = type_and_value_of_expr(se->expr); if (tav.mode == Addressing_Invalid) { @@ -3354,7 +3354,8 @@ lbAddr lb_build_addr(lbProcedure *p, Ast *expr) { GB_ASSERT(sel.entity != nullptr); if (sel.pseudo_field) { GB_ASSERT(sel.entity->kind == Entity_Procedure); - return lb_addr(lb_find_value_from_entity(p->module, sel.entity)); + Entity *e = entity_of_node(sel_node); + return lb_addr(lb_find_value_from_entity(p->module, e)); } { From 3380ece4a1003a068377e0a9c884d6e177a23d63 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 15 Feb 2022 15:16:48 +0000 Subject: [PATCH 62/64] Add utility calls for creating buffers from slices --- core/sys/darwin/Metal/MetalClasses.odin | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/core/sys/darwin/Metal/MetalClasses.odin b/core/sys/darwin/Metal/MetalClasses.odin index 2686ce2ae..e5b6d0849 100644 --- a/core/sys/darwin/Metal/MetalClasses.odin +++ b/core/sys/darwin/Metal/MetalClasses.odin @@ -1,6 +1,7 @@ package objc_Metal import NS "core:sys/darwin/Foundation" +import "core:mem" //////////////////////////////////////////////////////////////////////////////// @@ -6465,6 +6466,16 @@ Device_newBufferWithBytes :: #force_inline proc(self: ^Device, bytes: []byte, op Device_newBufferWithBytesNoCopy :: #force_inline proc(self: ^Device, bytes: []byte, options: ResourceOptions, deallocator: rawptr) -> ^Buffer { return msgSend(^Buffer, self, "newBufferWithBytesNoCopy:length:options:deallocator:", raw_data(bytes), NS.UInteger(len(bytes)), options, deallocator) } + +@(objc_type=Device, objc_name="newBufferWithSlice") +Device_newBufferWithSlice :: #force_inline proc(self: ^Device, slice: $S/[]$E, options: ResourceOptions) -> ^Buffer { + return Device_newBufferWithBytes(self, mem.slice_to_bytes(slice), options) +} +@(objc_type=Device, objc_name="newBufferWithSliceNoCopy") +Device_newBufferWithSliceNoCopy :: #force_inline proc(self: ^Device, slice: $S/[]$E, options: ResourceOptions, deallocator: rawptr) -> ^Buffer { + return Device_newBufferWithBytesNotCopy(self, mem.slice_to_bytes(slice), options, deallocator) +} + @(objc_type=Device, objc_name="newBuffer") Device_newBuffer :: #force_inline proc(self: ^Device, length: NS.UInteger, options: ResourceOptions) -> ^Buffer { return msgSend(^Buffer, self, "newBufferWithLength:options:", length, options) @@ -7263,7 +7274,7 @@ IndirectRenderCommand_drawPatches :: #force_inline proc(self: ^IndirectRenderCom msgSend(nil, self, "drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride) } @(objc_type=IndirectRenderCommand, objc_name="drawPrimitives") -IndirectRenderCommand_drawPrimitives :: #force_inline proc(self: ^IndirectRenderCommand, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger, instanceCount: NS.UInteger = 0, baseInstance: NS.UInteger = 0) { +IndirectRenderCommand_drawPrimitives :: #force_inline proc(self: ^IndirectRenderCommand, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger = 0) { msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:", primitiveType, vertexStart, vertexCount, instanceCount, baseInstance) } @(objc_type=IndirectRenderCommand, objc_name="reset") From 3ab5db82975f20190c4f1ffc2a06d02c5b8d98c4 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 15 Feb 2022 15:17:21 +0000 Subject: [PATCH 63/64] Add README.md --- core/sys/darwin/Metal/README.md | 155 ++++++++++++++++++++++++++++++++ 1 file changed, 155 insertions(+) create mode 100644 core/sys/darwin/Metal/README.md diff --git a/core/sys/darwin/Metal/README.md b/core/sys/darwin/Metal/README.md new file mode 100644 index 000000000..e61d7f7aa --- /dev/null +++ b/core/sys/darwin/Metal/README.md @@ -0,0 +1,155 @@ +## About + +**metal-odin** is a low overhead Odin interface for Metal that helps developers add Metal functionality to graphics applications that are written in Odin. **metal-odin** removes the need to create a shim and allows developers to call Metal functions directly from anywhere in their existing Odin code. + +## Highlights + +- Drop in Odin alternative interface to the Metal Objective-C headers. +- Direct mapping of all Metal Objective-C classes, constants, enums and bit_sets to Odin +- No measurable overhead compared to calling Metal Objective-C headers, due to inlining of Odin procedure calls. +- No usage of wrapper containers that require additional allocations. +- Identical header files and procedure/constant/enum availability for iOS, macOS and tvOS. +- Backwards compatibility: All `MTL.Device.supports...()` procedure check if their required selectors exist and automatically return `false` if not. +- String (`ErrorDomain`) constants are `@(linkage="weak")` and automatically set to `nil` if not available. + +## Memory Allocation Policy + +**metal-odin** follows the object allocation policies of Cocoa and Cocoa Touch. Understanding those rules is especially important when using `metal-odin`, as Odin values are not eligible for automatic reference counting (ARC). + +**metal-odin** objects are reference counted. To help convey and manage object lifecycles, the following conventions are observed: + +### AutoreleasePools and Objects + +Several methods that create temporary objects in **metal-odin** add them to an `AutoreleasePool` to help manage their lifetimes. In these situations, after **metal-odin** creates the object, it adds it to an `AutoreleasePool`, which will release its objects when you release (or drain) it. + +By adding temporary objects to an AutoreleasePool, you do not need to explicitly call `release()` to deallocate them. Instead, you can rely on the `AutoreleasePool` to implicitly manage those lifetimes. + +If you create an object with a method that does not begin with `alloc`, or `copy`, the creating method adds the object to an autorelease pool. + +The typical scope of an `AutoreleasePool` is one frame of rendering for the main thread of the program. When the thread returns control to the RunLoop (an object responsible for receiving input and events from the windowing system), the pool is *drained*, releasing its objects. + +You can create and manage additional `AutoreleasePool`s at smaller scopes to reduce your program's working set, and you are required to do so for any additional threads your program creates. + +If an object's lifecycle needs to be extended beyond the `AutoreleasePool`'s scope, you can claim ownership of it (avoiding its release beyond the pool's scope) by calling its `retain()` method before its pool is drained. In these cases, you will be responsible for making the appropriate `release()` call on the object after you no longer need it. + +You can find a more-detailed introduction to the memory management rules here: https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/MemoryMgmt/Articles/mmRules.html. + +For more details about the application's RunLoop, please find its documentation here: https://developer.apple.com/documentation/foundation/nsrunloop + +### Use and debug AutoreleasePools + +When you create an autoreleased object and there is no enclosing `AutoreleasePool`, the object is leaked. + +To prevent this, you normally create an `AutoreleasePool` in your program's `main` procedure, and in the entry procedure for every thread you create. You may also create additional `AutoreleasePool`s to avoid growing your program's high memory watermark when you create several autoreleased objects, such as when rendering. + +Use the Environment Variable `OBJC_DEBUG_MISSING_POOLS=YES` to print a runtime warning when an autoreleased object is leaked because no enclosing `AutoreleasePool` is available for its thread. + +You can also run `leaks --autoreleasePools` on a memgraph file or a process ID (macOS only) to view a listing of your program's `AutoreleasePool`s and all objects they contain. + +### nil + +Similar to Objective-C, it is legal to call any method, including `retain()` and `release()`, on `nil` "objects". While calling methods on `nil` still does incur in procedure call overhead, the effective result is equivalent of a NOP. + +Conversely, do not assume that because calling a method on a pointer did not result in a crash, that the pointed-to object is valid. + +## Adding `metal-odin` to a Project + +Simply `import MTL "core:sys/darwin/Metal"`. To ensure that the selector and class symbols are linked. + +```odin +import MTL "core:sys/darwin/Metal" +``` + +## Examples + +#### Creating the device + +###### Objective-C (with automatic reference counting) + +```objc +id< MTLDevice > device = MTLCreateSystemDefaultDevice(); + +// ... +``` + +###### Objective-C + +```objc +id< MTLDevice > device = MTLCreateSystemDefaultDevice(); + +// ... + +[device release]; +``` + +###### Odin + +```odin +device := MTL.CreateSystemDefaultDevice() + +// ... + +device->release() +``` + +#### Metal function calls map directly to Odin + +###### Objective-C (with automatic reference counting) + +```objc +MTLSamplerDescriptor* samplerDescriptor = [[MTLSamplerDescriptor alloc] init]; + +[samplerDescriptor setSAddressMode: MTLSamplerAddressModeRepeat]; +[samplerDescriptor setTAddressMode: MTLSamplerAddressModeRepeat]; +[samplerDescriptor setRAddressMode: MTLSamplerAddressModeRepeat]; +[samplerDescriptor setMagFilter: MTLSamplerMinMagFilterLinear]; +[samplerDescriptor setMinFilter: MTLSamplerMinMagFilterLinear]; +[samplerDescriptor setMipFilter: MTLSamplerMipFilterLinear]; +[samplerDescriptor setSupportArgumentBuffers: YES]; + +id< MTLSamplerState > samplerState = [device newSamplerStateWithDescriptor:samplerDescriptor]; +``` + +###### Objective-C + +```objc +MTLSamplerDescriptor* samplerDescriptor = [[MTLSamplerDescriptor alloc] init]; + +[samplerDescriptor setSAddressMode: MTLSamplerAddressModeRepeat]; +[samplerDescriptor setTAddressMode: MTLSamplerAddressModeRepeat]; +[samplerDescriptor setRAddressMode: MTLSamplerAddressModeRepeat]; +[samplerDescriptor setMagFilter: MTLSamplerMinMagFilterLinear]; +[samplerDescriptor setMinFilter: MTLSamplerMinMagFilterLinear]; +[samplerDescriptor setMipFilter: MTLSamplerMipFilterLinear]; +[samplerDescriptor setSupportArgumentBuffers: YES]; + +id< MTLSamplerState > samplerState = [device newSamplerStateWithDescriptor:samplerDescriptor]; + +[samplerDescriptor release]; + +// ... + +[samplerState release]; +``` + +###### Odin + +```odin +samplerDescriptor := MTL.SamplerDescriptor.alloc()->init() + +samplerDescriptor->setSAddressMode(.Repeat) +samplerDescriptor->setTAddressMode(.Repeat) +samplerDescriptor->setRAddressMode(.Repeat) +samplerDescriptor->setMagFilter(.Linear) +samplerDescriptor->setMinFilter(.Linear) +samplerDescriptor->setMipFilter(.Linear) +samplerDescriptor->setSupportArgumentBuffers(true) + +samplerState := device->newSamplerState(samplerDescriptor) + +samplerDescriptor->release() + +// ... + +samplerState->release() +``` From 803648be894659409beb3c2b5e76b7b491ddf7c5 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 15 Feb 2022 15:34:07 +0000 Subject: [PATCH 64/64] Minor aesthetic clean ups of Foundation --- core/sys/darwin/Foundation/NSBundle.odin | 6 ------ core/sys/darwin/Foundation/NSDate.odin | 1 - core/sys/darwin/Foundation/NSDictionary.odin | 1 - core/sys/darwin/Foundation/NSNotification.odin | 1 - core/sys/darwin/Foundation/NSNumber.odin | 1 - core/sys/darwin/Foundation/NSString.odin | 6 +++--- core/sys/darwin/Foundation/NSURL.odin | 5 ++++- core/sys/darwin/Foundation/NSWindow.odin | 7 ------- 8 files changed, 7 insertions(+), 21 deletions(-) diff --git a/core/sys/darwin/Foundation/NSBundle.odin b/core/sys/darwin/Foundation/NSBundle.odin index 4f5a8e928..5e136378b 100644 --- a/core/sys/darwin/Foundation/NSBundle.odin +++ b/core/sys/darwin/Foundation/NSBundle.odin @@ -105,7 +105,6 @@ Bundle_sharedFrameworksURL :: proc(self: ^Bundle) -> ^URL { return msgSend(^URL, self, "sharedFrameworksURL") } - @(objc_type=Bundle, objc_name="sharedSupportURL") Bundle_sharedSupportURL :: proc(self: ^Bundle) -> ^URL { return msgSend(^URL, self, "sharedSupportURL") @@ -121,9 +120,6 @@ Bundle_appStoreReceiptURL :: proc(self: ^Bundle) -> ^URL { return msgSend(^URL, self, "appStoreReceiptURL") } - - - @(objc_type=Bundle, objc_name="bundlePath") Bundle_bundlePath :: proc(self: ^Bundle) -> ^String { return msgSend(^String, self, "bundlePath") @@ -154,7 +150,6 @@ Bundle_sharedFrameworksPath :: proc(self: ^Bundle) -> ^String { return msgSend(^String, self, "sharedFrameworksPath") } - @(objc_type=Bundle, objc_name="sharedSupportPath") Bundle_sharedSupportPath :: proc(self: ^Bundle) -> ^String { return msgSend(^String, self, "sharedSupportPath") @@ -175,7 +170,6 @@ Bundle_bundleIdentifier :: proc(self: ^Bundle) -> ^String { return msgSend(^String, self, "bundleIdentifier") } - @(objc_type=Bundle, objc_name="infoDictionary") Bundle_infoDictionary :: proc(self: ^Bundle) -> ^Dictionary { return msgSend(^Dictionary, self, "infoDictionary") diff --git a/core/sys/darwin/Foundation/NSDate.odin b/core/sys/darwin/Foundation/NSDate.odin index cd63d313a..e30cb07d0 100644 --- a/core/sys/darwin/Foundation/NSDate.odin +++ b/core/sys/darwin/Foundation/NSDate.odin @@ -13,7 +13,6 @@ Date_init :: proc(self: ^Date) -> ^Date { return msgSend(^Date, self, "init") } - @(objc_type=Date, objc_name="dateWithTimeIntervalSinceNow") Date_dateWithTimeIntervalSinceNow :: proc(secs: TimeInterval) -> ^Date { return msgSend(^Date, Date, "dateWithTimeIntervalSinceNow:", secs) diff --git a/core/sys/darwin/Foundation/NSDictionary.odin b/core/sys/darwin/Foundation/NSDictionary.odin index 1f009841a..3832c05f1 100644 --- a/core/sys/darwin/Foundation/NSDictionary.odin +++ b/core/sys/darwin/Foundation/NSDictionary.odin @@ -29,7 +29,6 @@ Dictionary_init :: proc(self: ^Dictionary) -> ^Dictionary { return msgSend(^Dictionary, self, "init") } - @(objc_type=Dictionary, objc_name="initWithObjects") Dictionary_initWithObjects :: proc(self: ^Dictionary, objects: [^]^Object, forKeys: [^]^Object, count: UInteger) -> ^Dictionary { return msgSend(^Dictionary, self, "initWithObjects:forKeys:count", objects, forKeys, count) diff --git a/core/sys/darwin/Foundation/NSNotification.odin b/core/sys/darwin/Foundation/NSNotification.odin index 182d33896..ec8dddab7 100644 --- a/core/sys/darwin/Foundation/NSNotification.odin +++ b/core/sys/darwin/Foundation/NSNotification.odin @@ -14,7 +14,6 @@ Notification_init :: proc(self: ^Notification) -> ^Notification { return msgSend(^Notification, self, "init") } - @(objc_type=Notification, objc_name="name") Notification_name :: proc(self: ^Notification) -> ^String { return msgSend(^String, self, "name") diff --git a/core/sys/darwin/Foundation/NSNumber.odin b/core/sys/darwin/Foundation/NSNumber.odin index 4f7ef311b..016698805 100644 --- a/core/sys/darwin/Foundation/NSNumber.odin +++ b/core/sys/darwin/Foundation/NSNumber.odin @@ -63,7 +63,6 @@ Value_pointerValue :: proc(self: ^Value) -> rawptr { @(objc_class="NSNumber") Number :: struct{using _: Copying(Number), using _: Value} - @(objc_type=Number, objc_name="alloc", objc_is_class_method=true) Number_alloc :: proc() -> ^Number { return msgSend(^Number, Number, "alloc") diff --git a/core/sys/darwin/Foundation/NSString.odin b/core/sys/darwin/Foundation/NSString.odin index ae1d6d43f..45b5df37b 100644 --- a/core/sys/darwin/Foundation/NSString.odin +++ b/core/sys/darwin/Foundation/NSString.odin @@ -49,12 +49,12 @@ StringCompareOption :: enum UInteger { unichar :: distinct u16 -foreign Foundation { - __CFStringMakeConstantString :: proc "c" (c: cstring) -> ^String --- -} AT :: MakeConstantString MakeConstantString :: proc "c" (#const c: cstring) -> ^String { + foreign Foundation { + __CFStringMakeConstantString :: proc "c" (c: cstring) -> ^String --- + } return __CFStringMakeConstantString(c) } diff --git a/core/sys/darwin/Foundation/NSURL.odin b/core/sys/darwin/Foundation/NSURL.odin index 9813b6e59..72e5fc906 100644 --- a/core/sys/darwin/Foundation/NSURL.odin +++ b/core/sys/darwin/Foundation/NSURL.odin @@ -14,14 +14,17 @@ URL_init :: proc(self: ^URL) -> ^URL { return msgSend(^URL, self, "init") } - +@(objc_type=URL, objc_name="initWithString") URL_initWithString :: proc(self: ^URL, value: ^String) -> ^URL { return msgSend(^URL, self, "initWithString:", value) } + +@(objc_type=URL, objc_name="initFileURLWithPath") URL_initFileURLWithPath :: proc(self: ^URL, path: ^String) -> ^URL { return msgSend(^URL, self, "initFileURLWithPath:", path) } +@(objc_type=URL, objc_name="fileSystemRepresentation") URL_fileSystemRepresentation :: proc(self: ^URL) -> ^String { return msgSend(^String, self, "fileSystemRepresentation") } \ No newline at end of file diff --git a/core/sys/darwin/Foundation/NSWindow.odin b/core/sys/darwin/Foundation/NSWindow.odin index e109284d1..df675cfeb 100644 --- a/core/sys/darwin/Foundation/NSWindow.odin +++ b/core/sys/darwin/Foundation/NSWindow.odin @@ -23,7 +23,6 @@ View :: struct {using _: Responder} View_layer :: proc(self: ^View) -> ^Layer { return msgSend(^Layer, self, "layer") } - @(objc_type=View, objc_name="setLayer") View_setLayer :: proc(self: ^View, layer: ^Layer) { msgSend(nil, self, "setLayer:", layer) @@ -32,13 +31,10 @@ View_setLayer :: proc(self: ^View, layer: ^Layer) { 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") } - @(objc_type=View, objc_name="setWantsLayer") View_setWantsLayer :: proc(self: ^View, wantsLayer: BOOL) { msgSend(nil, self, "setWantsLayer:", wantsLayer) @@ -52,7 +48,6 @@ Window :: struct {using _: Responder} Window_contentView :: proc(self: ^Window) -> ^View { return msgSend(^View, self, "contentView") } - @(objc_type=Window, objc_name="frame") Window_frame :: proc(self: ^Window) -> Rect { return msgSend(Rect, self, "frame") @@ -61,7 +56,6 @@ Window_frame :: proc(self: ^Window) -> Rect { Window_setFrame :: proc(self: ^Window, frame: Rect) { msgSend(nil, self, "setFrame:", frame) } - @(objc_type=Window, objc_name="opaque") Window_opaque :: proc(self: ^Window) -> NS.BOOL { return msgSend(NS.BOOL, self, "opaque") @@ -70,7 +64,6 @@ Window_opaque :: proc(self: ^Window) -> NS.BOOL { Window_setOpaque :: proc(self: ^Window, ok: NS.BOOL) { msgSend(nil, self, "setOpaque:", ok) } - @(objc_type=Window, objc_name="backgroundColor") Window_backgroundColor :: proc(self: ^Window) -> ^NS.Color { return msgSend(^NS.Color, self, "backgroundColor")