From 51eb6f1f4edd0c6f80512ddf0614beeb2da8d4ed Mon Sep 17 00:00:00 2001 From: Ranie Jade Ramiso Date: Thu, 5 Mar 2020 20:12:18 +1100 Subject: [PATCH 1/2] Initial commit for benchmarks --- benchmarks/.gitignore | 2 + benchmarks/build.gradle.kts | 12 + benchmarks/bunnymark/Benchmarker.gd | 120 ++++++++++ benchmarks/bunnymark/Benchmarker.tscn | 22 ++ benchmarks/bunnymark/Cargo.toml | 14 ++ benchmarks/bunnymark/LICENSE | 21 ++ benchmarks/bunnymark/README.md | 93 ++++++++ benchmarks/bunnymark/Test.tscn | 6 + .../BunnymarkV1DrawTexture/Description.md | 3 + .../gd/BunnymarkV1DrawTexture.gd | 57 +++++ .../kt/BunnymarkV1DrawTexture.gdns | 6 + .../BunnymarkV1Sprites/Description.md | 3 + .../gd/BunnymarkV1Sprites.gd | 57 +++++ .../benchmarks/BunnymarkV2/Description.md | 3 + .../benchmarks/BunnymarkV2/gd/BunnymarkV2.gd | 69 ++++++ benchmarks/bunnymark/benchmarks/bunnymark.nim | 11 + .../bunnymark/benchmarks/bunnymark.nimble | 34 +++ .../bunnymark/benchmarks/bunnymarkv2.rs | 142 ++++++++++++ benchmarks/bunnymark/benchmarks/config.nims | 48 ++++ benchmarks/bunnymark/benchmarks/lib.rs | 14 ++ benchmarks/bunnymark/benchmarks/nim.cfg | 8 + benchmarks/bunnymark/benchmarks/package.d | 24 ++ benchmarks/bunnymark/build.gradle.kts | 29 +++ benchmarks/bunnymark/default_env.tres | 14 ++ benchmarks/bunnymark/dub.json | 15 ++ benchmarks/bunnymark/dub.selections.json | 6 + benchmarks/bunnymark/export_presets.cfg | 24 ++ benchmarks/bunnymark/icon.png | Bin 0 -> 3151 bytes benchmarks/bunnymark/icon.png.import | 34 +++ benchmarks/bunnymark/images/banner.png | Bin 0 -> 30147 bytes benchmarks/bunnymark/images/banner.png.import | 34 +++ benchmarks/bunnymark/images/bunny.svg | 217 ++++++++++++++++++ benchmarks/bunnymark/images/bunny.svg.import | 34 +++ benchmarks/bunnymark/images/godot_bunny.png | Bin 0 -> 1734 bytes .../bunnymark/images/godot_bunny.png.import | 34 +++ benchmarks/bunnymark/project.godot | 32 +++ benchmarks/bunnymark/run_benchmarks.sh | 14 ++ benchmarks/bunnymark/run_data/2017_10_29.json | 26 +++ benchmarks/bunnymark/run_data/2017_10_31.json | 29 +++ benchmarks/bunnymark/run_data/2018_02_21.json | 29 +++ benchmarks/bunnymark/run_data/2019_03_16.json | 32 +++ benchmarks/bunnymark/runs/2017_10_22.md | 56 +++++ benchmarks/bunnymark/runs/2017_10_29.md | 54 +++++ benchmarks/bunnymark/runs/2017_10_31.md | 53 +++++ benchmarks/bunnymark/runs/2018_02_21.md | 47 ++++ benchmarks/bunnymark/runs/2019_03_16.md | 50 ++++ benchmarks/bunnymark/settings.gradle.kts | 27 +++ .../kotlin/BunnymarkV1DrawTexture.kt | 95 ++++++++ .../src/godot/gdnlib/Benchmark.gdnlib | 18 ++ .../godot/gdns/BunnymarkV1DrawTexture.gdns | 6 + benchmarks/gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 58695 bytes .../gradle/wrapper/gradle-wrapper.properties | 5 + benchmarks/gradlew | 183 +++++++++++++++ benchmarks/gradlew.bat | 103 +++++++++ benchmarks/settings.gradle.kts | 31 +++ .../main/kotlin/godot/codegen/APIGenerator.kt | 181 ++++++++------- .../src/nativeGen/kotlin/godot/FuncRef.kt | 14 +- .../src/nativeGen/kotlin/godot/GDScript.kt | 14 +- .../nativeGen/kotlin/godot/NativeScript.kt | 14 +- .../src/nativeGen/kotlin/godot/Node.kt | 68 ++---- .../src/nativeGen/kotlin/godot/Object.kt | 38 ++- .../nativeGen/kotlin/godot/PluginScript.kt | 14 +- .../src/nativeGen/kotlin/godot/SceneTree.kt | 38 ++- .../src/nativeGen/kotlin/godot/TreeItem.kt | 16 +- .../src/nativeGen/kotlin/godot/UndoRedo.kt | 26 +-- .../kotlin/godot/methodBindUtils.kt | 39 ++++ 66 files changed, 2318 insertions(+), 244 deletions(-) create mode 100644 benchmarks/.gitignore create mode 100644 benchmarks/build.gradle.kts create mode 100644 benchmarks/bunnymark/Benchmarker.gd create mode 100644 benchmarks/bunnymark/Benchmarker.tscn create mode 100644 benchmarks/bunnymark/Cargo.toml create mode 100644 benchmarks/bunnymark/LICENSE create mode 100644 benchmarks/bunnymark/README.md create mode 100644 benchmarks/bunnymark/Test.tscn create mode 100644 benchmarks/bunnymark/benchmarks/BunnymarkV1DrawTexture/Description.md create mode 100644 benchmarks/bunnymark/benchmarks/BunnymarkV1DrawTexture/gd/BunnymarkV1DrawTexture.gd create mode 100644 benchmarks/bunnymark/benchmarks/BunnymarkV1DrawTexture/kt/BunnymarkV1DrawTexture.gdns create mode 100644 benchmarks/bunnymark/benchmarks/BunnymarkV1Sprites/Description.md create mode 100644 benchmarks/bunnymark/benchmarks/BunnymarkV1Sprites/gd/BunnymarkV1Sprites.gd create mode 100644 benchmarks/bunnymark/benchmarks/BunnymarkV2/Description.md create mode 100644 benchmarks/bunnymark/benchmarks/BunnymarkV2/gd/BunnymarkV2.gd create mode 100644 benchmarks/bunnymark/benchmarks/bunnymark.nim create mode 100644 benchmarks/bunnymark/benchmarks/bunnymark.nimble create mode 100644 benchmarks/bunnymark/benchmarks/bunnymarkv2.rs create mode 100644 benchmarks/bunnymark/benchmarks/config.nims create mode 100644 benchmarks/bunnymark/benchmarks/lib.rs create mode 100644 benchmarks/bunnymark/benchmarks/nim.cfg create mode 100644 benchmarks/bunnymark/benchmarks/package.d create mode 100644 benchmarks/bunnymark/build.gradle.kts create mode 100644 benchmarks/bunnymark/default_env.tres create mode 100644 benchmarks/bunnymark/dub.json create mode 100644 benchmarks/bunnymark/dub.selections.json create mode 100644 benchmarks/bunnymark/export_presets.cfg create mode 100644 benchmarks/bunnymark/icon.png create mode 100644 benchmarks/bunnymark/icon.png.import create mode 100644 benchmarks/bunnymark/images/banner.png create mode 100644 benchmarks/bunnymark/images/banner.png.import create mode 100644 benchmarks/bunnymark/images/bunny.svg create mode 100644 benchmarks/bunnymark/images/bunny.svg.import create mode 100644 benchmarks/bunnymark/images/godot_bunny.png create mode 100644 benchmarks/bunnymark/images/godot_bunny.png.import create mode 100644 benchmarks/bunnymark/project.godot create mode 100755 benchmarks/bunnymark/run_benchmarks.sh create mode 100644 benchmarks/bunnymark/run_data/2017_10_29.json create mode 100644 benchmarks/bunnymark/run_data/2017_10_31.json create mode 100644 benchmarks/bunnymark/run_data/2018_02_21.json create mode 100644 benchmarks/bunnymark/run_data/2019_03_16.json create mode 100644 benchmarks/bunnymark/runs/2017_10_22.md create mode 100644 benchmarks/bunnymark/runs/2017_10_29.md create mode 100644 benchmarks/bunnymark/runs/2017_10_31.md create mode 100644 benchmarks/bunnymark/runs/2018_02_21.md create mode 100644 benchmarks/bunnymark/runs/2019_03_16.md create mode 100644 benchmarks/bunnymark/settings.gradle.kts create mode 100644 benchmarks/bunnymark/src/benchmarkMain/kotlin/BunnymarkV1DrawTexture.kt create mode 100644 benchmarks/bunnymark/src/godot/gdnlib/Benchmark.gdnlib create mode 100644 benchmarks/bunnymark/src/godot/gdns/BunnymarkV1DrawTexture.gdns create mode 100644 benchmarks/gradle/wrapper/gradle-wrapper.jar create mode 100644 benchmarks/gradle/wrapper/gradle-wrapper.properties create mode 100755 benchmarks/gradlew create mode 100644 benchmarks/gradlew.bat create mode 100644 benchmarks/settings.gradle.kts diff --git a/benchmarks/.gitignore b/benchmarks/.gitignore new file mode 100644 index 00000000..babd7b4d --- /dev/null +++ b/benchmarks/.gitignore @@ -0,0 +1,2 @@ +addons +.import diff --git a/benchmarks/build.gradle.kts b/benchmarks/build.gradle.kts new file mode 100644 index 00000000..72f7cd60 --- /dev/null +++ b/benchmarks/build.gradle.kts @@ -0,0 +1,12 @@ +val godotProjects = listOf( + "bunnymark" +) + +gradle.includedBuilds.forEach { build -> + if (godotProjects.contains(build.name)) { + tasks.register("runGodot-${build.name}") { + group = "godot" + dependsOn(build.task(":runGodot")) + } + } +} \ No newline at end of file diff --git a/benchmarks/bunnymark/Benchmarker.gd b/benchmarks/bunnymark/Benchmarker.gd new file mode 100644 index 00000000..4a6c49a4 --- /dev/null +++ b/benchmarks/bunnymark/Benchmarker.gd @@ -0,0 +1,120 @@ +extends Control + +var fps_update_interval = 1.0 +var elapsed_time = 0.0 +var fps_label = null +var benchmark_container = null +var benchmark_node = null +var output_path = "user://benchmark_results.json" +var benchmark = null +var language = null +var arg_bench = "--bench=" +var arg_lang = "--lang=" + +# bunnymark +var bunnymark_target = 60.0 +var bunnymark_target_error = 0.5 +var benchmark_is_bunnymark = false +var bunnymark_update_interval = 2.0 +var stable_updates_required = 3 +var bunnymark_update_elapsed_time = 0.0 +var stable_updates = 0 + +var nativescript_languages = { + "kt": true +} + +func _ready(): + set_process(false) + fps_label = get_node("Panel/FPS") + benchmark_container = get_node("BenchmarkContainer") + + benchmark = "BunnymarkV1DrawTexture" + language = "kt" + + var args = OS.get_cmdline_args() + for arg in args: + if arg.substr(0, arg_bench.length()) == arg_bench: + benchmark = arg.split("=")[1] + elif arg.substr(0, arg_lang.length()) == arg_lang: + language = arg.split("=")[1] + + start_benchmark(benchmark, language) + +func _process(delta): + elapsed_time += delta + if elapsed_time >= fps_update_interval: + fps_label.text = "FPS: " + str(Engine.get_frames_per_second()) + elapsed_time = 0.0 + if benchmark_is_bunnymark: + update_bunnymark(delta) + +func start_benchmark(benchmark_name, language): + var language_extension = language + if nativescript_languages.has(language) and nativescript_languages[language]: + language_extension = "gdns" + var script_path = "res://benchmarks/" + benchmark_name + "/" + language + "/" + benchmark_name + "." + language_extension + benchmark_is_bunnymark = benchmark_name.begins_with("Bunnymark") + bunnymark_update_elapsed_time = bunnymark_update_interval + var script = load(script_path) + benchmark_node = Node2D.new() + benchmark_node.set_script(script) + benchmark_node.add_user_signal("benchmark_finished", ["output"]) + benchmark_node.connect("benchmark_finished", self, "benchmark_finished") + benchmark_container.add_child(benchmark_node) + if benchmark_node.has_method("add_bunny"): + set_process(true) + else: + benchmark_finished(0) + +func benchmark_finished(output): + print("benchmark output: ", output) + benchmark_container.remove_child(benchmark_node) + write_result(output) + get_tree().quit() + +func write_result(output): + print("written ", output) + var file = File.new() + file.open(output_path, File.READ) + var parse_result = JSON.parse(file.get_as_text()) + var benchmark_file = null + if parse_result.get_error() == 0: + benchmark_file = parse_result.get_result() + if benchmark_file == null or typeof(benchmark_file) != TYPE_DICTIONARY: + benchmark_file = { + "benchmark_results": {} + } + file.close() + benchmark_file["benchmark_results"][benchmark + "_" + language] = output + var dir = Directory.new() + dir.remove(output_path) + file = File.new() + file.open(output_path, File.WRITE) + benchmark_file["run_date"] = OS.get_datetime() + +func update_bunnymark(delta): + bunnymark_update_elapsed_time += delta + if bunnymark_update_elapsed_time > bunnymark_update_interval: + var fps = Engine.get_frames_per_second() + var difference = fps - bunnymark_target + var bunny_difference = 0 + if difference > bunnymark_target_error: + bunny_difference = min(1000, max(1, floor(20 * difference))) + elif difference < -bunnymark_target_error: + bunny_difference = max(-1000, min(-1, -1*ceil(20 * difference))) + if difference < bunnymark_target_error: + stable_updates += 1 + if stable_updates == stable_updates_required: + benchmark_node.finish() + else: + if bunny_difference > 0: + for i in range(bunny_difference): + benchmark_node.add_bunny() + else: + for i in range(-1*bunny_difference): + benchmark_node.remove_bunny() + + stable_updates = 0 + + bunnymark_update_elapsed_time = 0.0 diff --git a/benchmarks/bunnymark/Benchmarker.tscn b/benchmarks/bunnymark/Benchmarker.tscn new file mode 100644 index 00000000..9aa79bcc --- /dev/null +++ b/benchmarks/bunnymark/Benchmarker.tscn @@ -0,0 +1,22 @@ +[gd_scene load_steps=2 format=2] + +[ext_resource path="res://Benchmarker.gd" type="Script" id=1] + +[node name="Benchmarker" type="Control"] +anchor_right = 1.0 +anchor_bottom = 1.0 +script = ExtResource( 1 ) + +[node name="BenchmarkContainer" type="Node2D" parent="."] + +[node name="Panel" type="Panel" parent="."] +margin_right = 83.0 +margin_bottom = 14.0 + +[node name="FPS" type="Label" parent="Panel"] +anchor_right = 1.0 +anchor_bottom = 1.0 +text = "FPS:" +__meta__ = { +"_edit_use_anchors_": false +} diff --git a/benchmarks/bunnymark/Cargo.toml b/benchmarks/bunnymark/Cargo.toml new file mode 100644 index 00000000..0c860d53 --- /dev/null +++ b/benchmarks/bunnymark/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "godot3-bunnymark" +version = "0.1.0" +authors = ["Carter Anderson "] +edition = "2018" + +[lib] +path = "benchmarks/lib.rs" +crate-type = ["cdylib"] + +[dependencies] +gdnative = { git = "https://github.com/GodotNativeTools/godot-rust" } +euclid = "*" +rand = "0.6" diff --git a/benchmarks/bunnymark/LICENSE b/benchmarks/bunnymark/LICENSE new file mode 100644 index 00000000..2a723916 --- /dev/null +++ b/benchmarks/bunnymark/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2017 Michael "Carter" Anderson + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/benchmarks/bunnymark/README.md b/benchmarks/bunnymark/README.md new file mode 100644 index 00000000..bd4a082c --- /dev/null +++ b/benchmarks/bunnymark/README.md @@ -0,0 +1,93 @@ +![Godot Bunnymark](images/banner.png) + +Renders an increasing number of bunny sprites until a stable 60fps is hit. This is a decent test of real world usage as it combines Godot api usage with raw computation. I plan to update this README whenever significant performance changes occur or when new languages are added. Feel free to contribute language implementations or improvements! + +## Disclaimer + +The performance differences here might appear significant, but these benchmarks test the limits of each language (and the engine), which most games will never hit. Do not pick a language because it is "fastest" unless you know you need the fastest language. The smarter choice would be to pick the language you are most productive in. I personally think that most people will be more productive in GDScript or C#. A lot of time and energy went into making GDScript an integrated, seamless experience so it is a good starting point if you don't have a preference for any of the other languages listed. + +It is also important to note that C#/Mono and GDNative are both very young. Its possible that their performance characteristics will change. And please don't use these benchmarks to say "Language X is better / faster than Language Y", we don't have enough data to make those assertions. If anything this proves that any of the choices below are viable. Choose the language that you are comfortable with and do your own testing to cover your own scenarios. + +## Updates + +Follow me on twitter [@cart_cart](https://twitter.com/cart_cart) if you want Bunnymark updates or updates on my other projects! + +## Running + +* Build C++ files + * Setup headers and bindings using [these directions](https://github.com/GodotNativeTools/godot-cpp) + * run ```make``` in the root of this project +* Build C# files + * run ```msbuild /p:Configuration=Tools;DebugSymbols=false;Optimize=true``` (some terminals might require escaping some of those symbols) +* Build Nim files + * Setup headers and bindings using [these directions](https://pragmagic.github.io/godot-nim/master/index.html) + * run ```nake build``` +* Build D files + * `git clone` [godot-d](https://github.com/GodotNativeTools/godot-d) to your favorite directory + * [generate the bindings](https://github.com/GodotNativeTools/godot-d/blob/master/generator/README.md) + * run `dub add-local /path/to/godot-d/` + * run `dub build -b release` +* Build Rust files + * run `cargo build --release` +* Build Godot with the [ECMAScript module](https://github.com/Geequlim/ECMAScript) if you want to run the ECMAScript tests +* run ```sh run_benchmarks.sh``` +* wait! This will take some time ... the automation code is still a bit naive so it takes awhile to converge on 60 fps +* view the results in ```USER_HOME_DIRECTORY/.godot/app_userdata/Bunnymark/benchmark_results.json``` + +## Benchmark Run - March 16, 2019 + +### BunnymarkV2 + +Attempts to draw as many sprites as possible using Sprite nodes. It calls GetChildren() to iterate over a list of Sprites and sets their positions. It also updates a Label's text once per frame. This test aims to be a better emulation of real world api usage than the V1 tests. + +| Language | Bunnies Rendered | +|----------------------|------------------| +| ECMAScript/Javascript| 4660 | +| GDScript (Release) | 18560 | +| C#/Mono | 27555 | +| GDNative (D) | 28020 | +| GDNative (Nim) | 29920 | +| GDNative (C++) | 37480 | + +### BunnymarkV1 - DrawTexture + +Attempts to draw as many sprites to the screen as possible by drawing textures directly with VisualServer. This test focuses on compute / render performance and avoids making godot api calls. + +| Language | Bunnies Rendered | +|----------------------|------------------| +| ECMAScript/Javascript| 4340 | +| GDScript (Release) | 20540 | +| C#/Mono | 36720 | +| GDNative (Nim) | 60056 | +| GDNative (C++) | 65580 | +| GDNative (D) | 67840 | + +### BunnymarkV1 - Sprites + +Attempts to draw as many sprites to the screen as possible by adding Sprite nodes. This test focuses on compute / render performance and avoids making godot api calls. + +| Language | Bunnies Rendered | +|----------------------|------------------| +| ECMAScript/Javascript| 4300 | +| GDScript (Release) | 17639 | +| GDNative (Nim) | 37180 | +| C#/Mono | 37455 | +| GDNative (D) | 38740 | +| GDNative (C++) | 41935 | + +### Hardware: + +* CPU: Intel i7 7700k 4.2GHz +* GPU: Nvidia GeForce GTX 1070 +* RAM: 16GB DDR4 + +### Build Info: +* OS: Arch Linux +* Official Godot 3.1 release + +## Credits + +* GDScript example adapted from: https://github.com/curly-brace/godot-bunnies. Thanks [@curly-brace](https://github.com/curly-brace)! +* [@Capital-EX](https://github.com/Capital-EX) provided the initial Nim tests, the D tests, and the display server tests +* [@endragor](https://github.com/endragor) updated the GDNative tests to work with Godot 3.0 stable +* [@Geequlim](https://github.com/Geequlim) added ECMAScript tests diff --git a/benchmarks/bunnymark/Test.tscn b/benchmarks/bunnymark/Test.tscn new file mode 100644 index 00000000..bc09c2b9 --- /dev/null +++ b/benchmarks/bunnymark/Test.tscn @@ -0,0 +1,6 @@ +[gd_scene load_steps=2 format=2] + +[ext_resource path="res://benchmarks/BunnymarkV1DrawTexture/d/BunnymarkV1DrawTexture.gdns" type="Script" id=1] + +[node name="Test" type="Node2D"] +script = ExtResource( 1 ) diff --git a/benchmarks/bunnymark/benchmarks/BunnymarkV1DrawTexture/Description.md b/benchmarks/bunnymark/benchmarks/BunnymarkV1DrawTexture/Description.md new file mode 100644 index 00000000..3323dab1 --- /dev/null +++ b/benchmarks/bunnymark/benchmarks/BunnymarkV1DrawTexture/Description.md @@ -0,0 +1,3 @@ +# BunnymarkV1DrawTexture + +Attempts to draw as many sprites to the screen as possible by drawing textures directly with VisualServer. This test focuses on compute / render performance and avoids making godot api calls. \ No newline at end of file diff --git a/benchmarks/bunnymark/benchmarks/BunnymarkV1DrawTexture/gd/BunnymarkV1DrawTexture.gd b/benchmarks/bunnymark/benchmarks/BunnymarkV1DrawTexture/gd/BunnymarkV1DrawTexture.gd new file mode 100644 index 00000000..4be579bf --- /dev/null +++ b/benchmarks/bunnymark/benchmarks/BunnymarkV1DrawTexture/gd/BunnymarkV1DrawTexture.gd @@ -0,0 +1,57 @@ +extends Node2D + +var bunnies = [] +var bunny_texture = load("res://images/godot_bunny.png") +var grav = 500 +var screen_size + +func _draw(): + for bunny in bunnies: + draw_texture(bunny_texture, bunny[0]) + +func _process(delta): + screen_size = get_viewport_rect().size + + for bunny in bunnies: + var pos = bunny[0] + var newPosition = bunny[1] + + pos.x += newPosition.x * delta + pos.y += newPosition.y * delta + + newPosition.y += grav * delta + + if pos.x > screen_size.x: + newPosition.x *= -1 + pos.x = screen_size.x + + if pos.x < 0: + newPosition.x *= -1 + pos.x = 0 + + if pos.y > screen_size.y: + pos.y = screen_size.y + if randf() > 0.5: + newPosition.y = -(randi() % 1100 + 50) + else: + newPosition.y *= -0.85 + + if pos.y < 0: + newPosition.y = 0 + pos.y = 0 + + bunny[0] = pos + bunny[1] = newPosition + update() + +func add_bunny(): + bunnies.append([Vector2(screen_size.x / 2, screen_size.y / 2), Vector2(randi() % 200 + 50, randi() % 200 + 50)]) + +func remove_bunny(): + if bunnies.size() == 0: + return + + bunnies.pop_back() + +func finish(): + emit_signal("benchmark_finished", bunnies.size()) \ No newline at end of file diff --git a/benchmarks/bunnymark/benchmarks/BunnymarkV1DrawTexture/kt/BunnymarkV1DrawTexture.gdns b/benchmarks/bunnymark/benchmarks/BunnymarkV1DrawTexture/kt/BunnymarkV1DrawTexture.gdns new file mode 100644 index 00000000..4c34b213 --- /dev/null +++ b/benchmarks/bunnymark/benchmarks/BunnymarkV1DrawTexture/kt/BunnymarkV1DrawTexture.gdns @@ -0,0 +1,6 @@ +[gd_resource type="NativeScript" load_steps=2 format=2] +[ext_resource path="res://src/godot/gdnlib/Benchmark.gdnlib" type="GDNativeLibrary" id=1] +[resource] +resource_name="BunnymarkV1DrawTexture" +class_name="BunnymarkV1DrawTexture" +library=ExtResource(1) diff --git a/benchmarks/bunnymark/benchmarks/BunnymarkV1Sprites/Description.md b/benchmarks/bunnymark/benchmarks/BunnymarkV1Sprites/Description.md new file mode 100644 index 00000000..1763fde5 --- /dev/null +++ b/benchmarks/bunnymark/benchmarks/BunnymarkV1Sprites/Description.md @@ -0,0 +1,3 @@ +# BunnymarkV1DrawTexture + +Attempts to draw as many sprites to the screen as possible by adding Sprite nodes. This test focuses on compute / render performance and avoids making godot api calls. \ No newline at end of file diff --git a/benchmarks/bunnymark/benchmarks/BunnymarkV1Sprites/gd/BunnymarkV1Sprites.gd b/benchmarks/bunnymark/benchmarks/BunnymarkV1Sprites/gd/BunnymarkV1Sprites.gd new file mode 100644 index 00000000..5a5010ee --- /dev/null +++ b/benchmarks/bunnymark/benchmarks/BunnymarkV1Sprites/gd/BunnymarkV1Sprites.gd @@ -0,0 +1,57 @@ +extends Node2D + +var bunnies = [] +var grav = 500 +var bunny_texture = load("res://images/godot_bunny.png") +var screen_size + +func _process(delta): + screen_size = get_viewport_rect().size + + for bunny in bunnies: + var pos = bunny[0].position + var newPosition = bunny[1] + + pos.x += newPosition.x * delta + pos.y += newPosition.y * delta + + newPosition.y += grav * delta + + if pos.x > screen_size.x: + newPosition.x *= -1 + pos.x = screen_size.x + + if pos.x < 0: + newPosition.x *= -1 + pos.x = 0 + + if pos.y > screen_size.y: + pos.y = screen_size.y + if randf() > 0.5: + newPosition.y = -(randi() % 1100 + 50) + else: + newPosition.y *= -0.85 + + if pos.y < 0: + newPosition.y = 0 + pos.y = 0 + + bunny[0].position = pos + bunny[1] = newPosition + +func add_bunny(): + var bunny = Sprite.new() + bunny.set_texture(bunny_texture) + add_child(bunny) + bunny.position = Vector2(screen_size.x / 2, screen_size.y / 2) + bunnies.append([bunny, Vector2(randi() % 200 + 50, randi() % 200 + 50)]) + +func remove_bunny(): + if bunnies.size() == 0: + return + var bunny = bunnies[bunnies.size() - 1] + remove_child(bunny[0]) + bunnies.pop_back() + +func finish(): + emit_signal("benchmark_finished", bunnies.size()) \ No newline at end of file diff --git a/benchmarks/bunnymark/benchmarks/BunnymarkV2/Description.md b/benchmarks/bunnymark/benchmarks/BunnymarkV2/Description.md new file mode 100644 index 00000000..f42136f1 --- /dev/null +++ b/benchmarks/bunnymark/benchmarks/BunnymarkV2/Description.md @@ -0,0 +1,3 @@ +# BunnymarkV2 + +Attempts to draw as many sprites as possible using Sprite nodes. It calls GetChildren() to iterate over a list of Sprites and sets their positions. It also updates a Label's text once per frame. This test aims to be a better emulation of real world api usage than the V1 tests. \ No newline at end of file diff --git a/benchmarks/bunnymark/benchmarks/BunnymarkV2/gd/BunnymarkV2.gd b/benchmarks/bunnymark/benchmarks/BunnymarkV2/gd/BunnymarkV2.gd new file mode 100644 index 00000000..feb4215a --- /dev/null +++ b/benchmarks/bunnymark/benchmarks/BunnymarkV2/gd/BunnymarkV2.gd @@ -0,0 +1,69 @@ +extends Node2D + +var grav = 500 +var bunny_texture = load("res://images/godot_bunny.png") +var bunny_speeds = [] +var label = Label.new() +var bunnies = Node2D.new() +var screen_size + +func _ready(): + add_child(bunnies) + + label.rect_position = Vector2(0, 20) + add_child(label) + +func _process(delta): + screen_size = get_viewport_rect().size + label.text = "Bunnies: " + str(bunnies.get_child_count()) + + var bunny_children = bunnies.get_children() + for i in range(0, bunny_children.size()): + var bunny = bunny_children[i] + var pos = bunny.position + var speed = bunny_speeds[i] + + pos.x += speed.x * delta + pos.y += speed.y * delta + + speed.y += grav * delta + + if pos.x > screen_size.x: + speed.x *= -1 + pos.x = screen_size.x + + if pos.x < 0: + speed.x *= -1 + pos.x = 0 + + if pos.y > screen_size.y: + pos.y = screen_size.y + if randf() > 0.5: + speed.y = -(randi() % 1100 + 50) + else: + speed.y *= -0.85 + + if pos.y < 0: + speed.y = 0 + pos.y = 0 + + bunny.position = pos + bunny_speeds[i] = speed + +func add_bunny(): + var bunny = Sprite.new() + bunny.set_texture(bunny_texture) + bunnies.add_child(bunny) + bunny.position = Vector2(screen_size.x / 2, screen_size.y / 2) + bunny_speeds.push_back(Vector2(randi() % 200 + 50, randi() % 200 + 50)) + +func remove_bunny(): + var child_count = bunnies.get_child_count() + if child_count == 0: + return + var bunny = bunnies.get_child(child_count - 1) + bunny_speeds.pop_back() + bunnies.remove_child(bunny) + +func finish(): + emit_signal("benchmark_finished", bunnies.get_child_count()) \ No newline at end of file diff --git a/benchmarks/bunnymark/benchmarks/bunnymark.nim b/benchmarks/bunnymark/benchmarks/bunnymark.nim new file mode 100644 index 00000000..0c328f06 --- /dev/null +++ b/benchmarks/bunnymark/benchmarks/bunnymark.nim @@ -0,0 +1,11 @@ +# Copyright 2017 Xored Software, Inc. + +## Import independent scene objects here +## (no need to import everything, just independent roots) + +when not defined(release): + import segfaults # converts segfaults into NilAccessError + +import BunnymarkV1Sprites/nim/BunnymarkV1Sprites +import BunnymarkV1DrawTexture/nim/BunnymarkV1DrawTexture +import BunnymarkV2/nim/BunnymarkV2 diff --git a/benchmarks/bunnymark/benchmarks/bunnymark.nimble b/benchmarks/bunnymark/benchmarks/bunnymark.nimble new file mode 100644 index 00000000..0e2607b4 --- /dev/null +++ b/benchmarks/bunnymark/benchmarks/bunnymark.nimble @@ -0,0 +1,34 @@ +version = "0.1.0" +author = "Capital Ex" +description = "Godot-Nim Bunnymark" +license = "MIT" +bin = @["bunnymark"] + +requires "godot >= 0.7.6 & < 0.8.0" + +task make, "build": + const bitsPostfix = when sizeof(int) == 8: "_64" else: "_32" + const libFile = + when defined(windows): + "nim" & bitsPostfix & ".dll" + elif defined(ios): + "nim_ios" & bitsPostfix & ".dylib" + elif defined(macosx): + "nim_mac.dylib" + elif defined(android): + "nim_android.so" + elif defined(linux): + "nim_linux" & bitsPostfix & ".so" + else: nil + if libFile.isNil: + raise newException(OSError, "Unsupported platform") + + exec "nimble build -y" + const dir = "../_dlls/" + const target = dir & libFile + mkDir(dir) + when defined(windows): + rmFile(target) + mvFile(bin[0] & ".exe", target) + else: + mvFile(bin[0], target) diff --git a/benchmarks/bunnymark/benchmarks/bunnymarkv2.rs b/benchmarks/bunnymark/benchmarks/bunnymarkv2.rs new file mode 100644 index 00000000..62c54249 --- /dev/null +++ b/benchmarks/bunnymark/benchmarks/bunnymarkv2.rs @@ -0,0 +1,142 @@ +use euclid; +use gdnative::*; +use rand; + +#[derive(NativeClass)] +#[inherit(Node2D)] +pub struct BunnymarkV2 { + bunnies: Node2D, + bunny_speeds: Vec, + bunny_texture: Texture, + gravity: f32, + screen_size: euclid::Size2D, + label: Label, +} + +#[methods] +impl BunnymarkV2 { + fn _init(_owner: Node2D) -> Self { + // NOTE: Direct load call crashes with "handle_crash: Program crashed with signal 11" + let bunny_texture = unsafe { + ResourceLoader::godot_singleton() + /*.load("res://images/godot_bunny.png".into(), "".into(), false) + .unwrap() + .cast::() + .unwrap()*/ + .call( + "load".into(), + &[ + "res://images/godot_bunny.png".into(), + "".into(), + false.into(), + ], + ) + .try_to_object::() + .unwrap() + }; + BunnymarkV2 { + bunnies: Node2D::new(), + bunny_speeds: vec![], + bunny_texture, + gravity: 500., + screen_size: euclid::size2(0., 0.), + label: Label::new(), + } + } + + #[export] + unsafe fn _ready(&mut self, mut owner: Node2D) { + owner.set_process(true); + owner.add_child(Some(self.bunnies.to_object()), false); + + self.label.set_position(Vector2::new(0., 20.)); + owner.add_child(Some(self.label.to_object()), false); + } + + #[export] + fn _process(&mut self, owner: Node2D, delta: f32) { + unsafe { + self.screen_size = owner.get_viewport_rect().size; + self.label + .set_text(format!("Bunnies: {}", self.bunnies.get_child_count()).into()); + } + + let mut bunny_children = unsafe { self.bunnies.get_children() }; + for i in 0..bunny_children.len() as usize { + if let Some(mut bunny) = bunny_children + .get_mut_ref(i as i32) + .try_to_object::() + { + let mut position = unsafe { bunny.get_position() }; + let mut speed = self.bunny_speeds[i]; + + position.x += speed.x * delta; + position.y += speed.y * delta; + + speed.y += self.gravity * delta; + + if position.x > self.screen_size.width { + speed.x *= -1.; + position.x = self.screen_size.width; + } + if position.x < 0. { + speed.x *= -1.; + position.x = 0.; + } + + if position.y > self.screen_size.height { + position.y = self.screen_size.height; + if rand::random::() > 0.5 { + speed.y = -((rand::random::() % 1100 + 50) as f32); + } else { + speed.y *= -0.85; + } + } + + if position.y < 0. { + speed.y = 0.; + position.y = 0.; + } + + unsafe { bunny.set_position(position) }; + self.bunny_speeds[i] = speed; + } + } + } + + #[export] + unsafe fn add_bunny(&mut self, _owner: Node2D) { + let mut bunny = Sprite::new(); + bunny.set_texture(Some(self.bunny_texture.clone())); + self.bunnies.add_child(Some(bunny.to_object()), false); + bunny.set_position(Vector2::new( + self.screen_size.width / 2., + self.screen_size.height / 2., + )); + self.bunny_speeds.push(Vector2::new( + (rand::random::() % 200 + 50) as f32, + (rand::random::() % 200 + 50) as f32, + )); + } + + #[export] + unsafe fn remove_bunny(&mut self, _owner: Node2D) { + let child_count = self.bunnies.get_child_count(); + if child_count == 0 { + return; + }; + let bunny = self.bunnies.get_child(child_count - 1); + if let Some(bunny) = bunny { + self.bunnies.remove_child(Some(bunny.to_object())); + } + self.bunny_speeds.pop(); + } + + #[export] + unsafe fn finish(&self, mut owner: Node2D) { + owner.emit_signal( + "benchmark_finished".into(), + &[self.bunnies.get_child_count().into()], + ); + } +} diff --git a/benchmarks/bunnymark/benchmarks/config.nims b/benchmarks/bunnymark/benchmarks/config.nims new file mode 100644 index 00000000..2db222b5 --- /dev/null +++ b/benchmarks/bunnymark/benchmarks/config.nims @@ -0,0 +1,48 @@ +import ospaths + +switch("nimcache", ".nimcache"/hostOS/hostCPU) + +when defined(macosx): + when defined(ios): + if hostCPU == "arm64": + switch("passC", "-arch arm64") + switch("passL", "-arch arm64") + elif hostCPU == "arm": + switch("passC", "-arch armv7") + switch("passL", "-arch armv7") + switch("passC", "-mios-version-min=9.0 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk") + switch("passL", "-mios-version-min=9.0 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk") + else: + switch("passL", "-framework Cocoa") +elif defined(android): + let ndk = getEnv("ANDROID_NDK_ROOT") + let toolchain = getEnv("ANDROID_TOOLCHAIN") + + if ndk.len == 0: + raise newException(OSError, + "ANDROID_NDK_ROOT environment variable is necessary for android build") + if toolchain.len == 0: + raise newException(OSError, + "ANDROID_TOOLCHAIN environment variable is necessary for android build") + + const level = $16 # change this to the necessary API level + const arch = "arm" + let sysroot = "--sysroot=\"" & ndk & "/platforms/android-" & level & "/arch-" & arch & "/\"" + switch("passL", sysroot) + switch("passC", sysroot) + + switch("cc", "clang") + switch("arm.linux.clang.path", toolchain / "bin") + switch("arm.linux.clang.exe", arch & "-linux-androideabi-clang") + switch("arm.linux.clang.compilerexe", arch & "-linux-androideabi-clang") + switch("arm.linux.clang.linkerexe", arch & "-linux-androideabi-clang") +elif defined(windows): + assert(sizeof(int) == 8) + switch("cc", "vcc") +elif defined(linux): + switch("passC", "-fPIC") +else: + raise newException(OSError, "Unsupported platform: " & hostOS) + +when not defined(release): + switch("debugger", "native") diff --git a/benchmarks/bunnymark/benchmarks/lib.rs b/benchmarks/bunnymark/benchmarks/lib.rs new file mode 100644 index 00000000..710c5961 --- /dev/null +++ b/benchmarks/bunnymark/benchmarks/lib.rs @@ -0,0 +1,14 @@ +extern crate gdnative; + +use gdnative::*; +pub mod bunnymarkv2; + +// Function that registers all exposed classes to Godot +fn init(handle: gdnative::init::InitHandle) { + handle.add_class::(); +} + +// macros that create the entry-points of the dynamic library. +godot_gdnative_init!(); +godot_nativescript_init!(init); +godot_gdnative_terminate!(); diff --git a/benchmarks/bunnymark/benchmarks/nim.cfg b/benchmarks/bunnymark/benchmarks/nim.cfg new file mode 100644 index 00000000..026daa2e --- /dev/null +++ b/benchmarks/bunnymark/benchmarks/nim.cfg @@ -0,0 +1,8 @@ +--path:"$projectdir" +--path:"$projectdir/../_godotapi" +--app:lib +-d:useRealtimeGc +-d:release +--opt:speed +--noMain +--warning[LockLevel]:off \ No newline at end of file diff --git a/benchmarks/bunnymark/benchmarks/package.d b/benchmarks/bunnymark/benchmarks/package.d new file mode 100644 index 00000000..0be48cda --- /dev/null +++ b/benchmarks/bunnymark/benchmarks/package.d @@ -0,0 +1,24 @@ +module bunnymark; + +import std.stdio; + +import godot; +import godot.c; + +public import bunnymark.v2; +public import bunnymark.v1.draw_texture; +public import bunnymark.v1.sprites; + +// This is supposed to work with latest godot-d, but it doesn't work with Godot 3.0 + +mixin GodotNativeLibrary! +( + "godot_", // same as the symbol_prefix in the GDNativeLibrary resource + + BunnymarkV2, + BunnymarkV1DrawTexture, + BunnymarkV1Sprites, + + (GodotInitOptions o){ writeln("Library initialized"); }, + (GodotTerminateOptions o){ writeln("Library terminated"); } +); \ No newline at end of file diff --git a/benchmarks/bunnymark/build.gradle.kts b/benchmarks/bunnymark/build.gradle.kts new file mode 100644 index 00000000..2f6e1f9e --- /dev/null +++ b/benchmarks/bunnymark/build.gradle.kts @@ -0,0 +1,29 @@ +plugins { + kotlin("multiplatform") version "1.3.61" + id("com.github.raniejade.godot-kotlin") +} + +buildscript { + repositories { + jcenter() + } + dependencies { + classpath("godot-kotlin:build-support:0.1.0") + } +} + +repositories { + jcenter() + mavenCentral() +} + +godot { + isCompositeBuild.set(true) + libraries { + val benchmark by creating { + classes( + "BunnymarkV1DrawTexture" + ) + } + } +} \ No newline at end of file diff --git a/benchmarks/bunnymark/default_env.tres b/benchmarks/bunnymark/default_env.tres new file mode 100644 index 00000000..dfe62abb --- /dev/null +++ b/benchmarks/bunnymark/default_env.tres @@ -0,0 +1,14 @@ +[gd_resource type="Environment" load_steps=2 format=2] + +[sub_resource type="ProceduralSky" id=1] +sky_top_color = Color( 0.0470588, 0.454902, 0.976471, 1 ) +sky_horizon_color = Color( 0.556863, 0.823529, 0.909804, 1 ) +sky_curve = 0.25 +ground_bottom_color = Color( 0.101961, 0.145098, 0.188235, 1 ) +ground_horizon_color = Color( 0.482353, 0.788235, 0.952941, 1 ) +ground_curve = 0.01 +sun_energy = 16.0 + +[resource] +background_mode = 2 +background_sky = SubResource( 1 ) diff --git a/benchmarks/bunnymark/dub.json b/benchmarks/bunnymark/dub.json new file mode 100644 index 00000000..23c7f954 --- /dev/null +++ b/benchmarks/bunnymark/dub.json @@ -0,0 +1,15 @@ +{ + "name": "bunnymark-d", + "description" : "", + "authors" : ["Capital-Ex", "Cart"], + "license": "MIT", + "targetType": "dynamicLibrary", + "targetPath": "lib", + "sourcePaths": [ + "benchmarks" + ], + "dependencies": { + "godot-d": "*" + } + +} \ No newline at end of file diff --git a/benchmarks/bunnymark/dub.selections.json b/benchmarks/bunnymark/dub.selections.json new file mode 100644 index 00000000..7347a13e --- /dev/null +++ b/benchmarks/bunnymark/dub.selections.json @@ -0,0 +1,6 @@ +{ + "fileVersion": 1, + "versions": { + "godot-d": "0.1.2" + } +} diff --git a/benchmarks/bunnymark/export_presets.cfg b/benchmarks/bunnymark/export_presets.cfg new file mode 100644 index 00000000..8c2ef361 --- /dev/null +++ b/benchmarks/bunnymark/export_presets.cfg @@ -0,0 +1,24 @@ +[preset.0] + +name="Linux/X11" +platform="Linux/X11" +runnable=true +custom_features="release" +export_filter="all_resources" +include_filter="" +exclude_filter="" +export_path="/home/carter/code/godot3-bunnymark/export/Bunnymark.x86_64" +patch_list=PoolStringArray( ) +script_export_mode=1 +script_encryption_key="" + +[preset.0.options] + +texture_format/bptc=false +texture_format/s3tc=true +texture_format/etc=false +texture_format/etc2=false +texture_format/no_bptc_fallbacks=true +binary_format/64_bits=true +custom_template/release="" +custom_template/debug="" diff --git a/benchmarks/bunnymark/icon.png b/benchmarks/bunnymark/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..6e34367634b03a26cda10f171f745357256f0b38 GIT binary patch literal 3151 zcmV-V46yTwP)mJFQBPJq_fY}oJfwJsb@#amlj zi@n~qKM>)ybCm}GBKdBsyoU_{Gt07!+W~+z0WhB<3~GhI-`wu@?~R7??d|PXI~?=@ zGcOzP(CAzHYaWj$CnEs(d>uD3qZ)$2eiOoDfWzjwIOIr@__@#5{`g3g_j=FFRTS|y zGfz)4g391d6T+(l1_1Cl!!QLKPBTRg7+l8C1y1_16hz?~*wrkEfYtO^iuEi+SE0cdDwa1f!2RrCBWstoq& z{Xh`qnkH`?V%$Flh`BvrCzOwf^Mj@`h*0kHwNFhe0ELCw)c~?d8^X&bgZ(-n`h@>x zXXlyQ&R^u5oh<7v5Zko~?ymT5TvAkIKo z3}X>M7z|lPR$2j&B*|nUFzmz`?n{cqEGn+Q z&*|IOt*rpVFuT$UKxwJFnE=(2d;$=$UIS55)fS0h0e~D<*^>1W>Jt=2_NEm8qN{Zf z`79UrYQnlgU`BFop-U49)3nSQ3|&>l$@Eu(K$GR>L(f@3l4yD|uzYE60X2fwPRFE4 zlVWKHfMk4Z*+?Q$v`7*ros$SFSy*@fgj{6FFvADHZre=?S@%?(Aq0xO-qz}#+MfWL zMEc131}yQui~t}+W?@ zMK1uN003e!c_P5XBLIMG6fG$!|98fEf@H^T%dXm^sA*DO;#bY^tcmeYsjxKsGg419mE=S?9Ed)mU- z*AancCX~riB+RMEMlNiSq`q$w)C<&GjR8b;f%>)(6p3(Ui3{^9a`BZS=iq|K^r2Pv zx9kA`P+C*Do@JzLjRZ6kPaisq`nFJ?@&FJu1a>rqdO{#!d7{Mcj?aUL>R-HT2*zPg z6fYiiBcPds6+e({(o-YZJ}m=4Le}C28e`|NP?ymR!!732L_!p zC_e`^m(@(!HxdA7B$M5roxYsoI0`Y4&#L!Z5I0ii$vmfmh-Su3!A_YdmhF&T!FXyf zb}EEd=1xv6e6H=$vYJU7FNg;KK-tCB$H_+fQ(H|QbY3uSz!dCE)I~g~@&J%)lLyOQ zo{=g)VgLZZVUzC#Nl8H()dd)%LxPc%8~OxyN*hLlzvU3PWpn*10*-HAH~)b9)28hl z7q^^7#WDvlwC}KtzOlcdVPg zEh7Ld+W6jVBH9C>|K=PjaVbGx%&0(`sUp`NYzt`wAh+LeoSEmHydz zaUX!LF{*#SG>q@26@Y&{ys!mfxM|PZ0DpZ9ssGN-N9Ns; zvEwik|A!a@0LXDFSTbueW>ywKmIx=#bmNZ)Ti_25|659NjswfCoq`z?^I@2bBTb!n z<4_C2s*zHj3swsElFKIJrDa#)u4^Wv$YvmPwh{Ad3$XQ`nJCV23|slFD`sNeMR^FF zZA7u%z}>SZW6ScZ;Izr3>N}$bz>4cDF{vmEb#--Ex?~w1TC)~Qmn=iWC&zLBf|>#E zk1udx>Fg;OU*H<>?12R}XgF~!iO;TGyD_;a3oGVSj!giruPsF^7Q;(heg;iT^hqL- z2sXaB5woijA<>`K-aHle-B5*xZc4t@qDX{U)y3GjaTB7^XrlhmG;G`hh%kNnbUgXg6L@uRGzZgzD-lY}oKD1SD+R-!!TKD5J&b zlskkc{_Mb_&Fn^VqPyJ)I*>x>EZ!T4@J(XPE*_rH|S@3^wU)fLsS`xAFpTX!^YwmTN{ z1XT*ebcZaHnb8mkX$HVt6%Uwj2jV!yZRru zC4yO&@08y>e5R}Zq$J(<2XCq^l?bL_^gr=%p34?fWGO2U)r~<8_1=sEAb^9Z z8VSBo;+oeR4_u!G0O7cSU|dHiu0z#@tVo0=UpS=_O}?<9NQ4*exX)=GBi%J9RXroB7H|w&GCetHihmgt-7pM$DAqCBpm6 zyv>)F_pc+XuGU9WW=fl_nCaHd?@kkt=YUWHrYeA|2vp2K4#2LSQZ@uojDRo$K7bnu pXawUFk-2~Sx`m&Dh|?wJ{{h1jX>J%-DvkgE002ovPDHLkV1ln)(eMBO literal 0 HcmV?d00001 diff --git a/benchmarks/bunnymark/icon.png.import b/benchmarks/bunnymark/icon.png.import new file mode 100644 index 00000000..96cbf462 --- /dev/null +++ b/benchmarks/bunnymark/icon.png.import @@ -0,0 +1,34 @@ +[remap] + +importer="texture" +type="StreamTexture" +path="res://.import/icon.png-487276ed1e3a0c39cad0279d744ee560.stex" +metadata={ +"vram_texture": false +} + +[deps] + +source_file="res://icon.png" +dest_files=[ "res://.import/icon.png-487276ed1e3a0c39cad0279d744ee560.stex" ] + +[params] + +compress/mode=0 +compress/lossy_quality=0.7 +compress/hdr_mode=0 +compress/bptc_ldr=0 +compress/normal_map=0 +flags/repeat=0 +flags/filter=true +flags/mipmaps=false +flags/anisotropic=false +flags/srgb=2 +process/fix_alpha_border=true +process/premult_alpha=false +process/HDR_as_SRGB=false +process/invert_color=false +stream=false +size_limit=0 +detect_3d=true +svg/scale=1.0 diff --git a/benchmarks/bunnymark/images/banner.png b/benchmarks/bunnymark/images/banner.png new file mode 100644 index 0000000000000000000000000000000000000000..9037506c5dbf46f2e05c4a6bb9afe0f6b2a86aeb GIT binary patch literal 30147 zcmX_H1yCJLv%Rdnsy7>1GXa_+FWq9!A0dE`x z{u{woT*CnXfHVB}1HtZ=ya>LD>nNh`sAOa6=xktb0&sSAru$}X;b3H7YeHvZZ@^E*0$3NS2ld)e$x8Ll3(!fvH*x0zw$>sc9RPC_4yST8>vptC&&ZAXtU21J( zlc~4Q9`x@jy!~^>BKL^zgAH+>BQBiE#pzTkM|R2Nuru@*fs7L`-p$R8LX+$Cvx+B2 z6oKM2c4$xnCmrd(i<+>%)<8{7Eq#CO1Hg=6HhYbO|CkAuD3jIdI->d0FNNHe7SBfU z^J-Fclr={{P6!0?2uB08T!9V;cP3~^7zqN#e+eIh;*(r#9ignNhYI_sMrX) z;{3sp71!rzTbuWc^iYn+eZ4AYy?-ao+QO<+h5udgp9+kttE(L#87>(_hrZ`m>R_e% z^j%4F_9iShIkN@L(c|XQ!!b}U13RlzcXXIchwe4dJ3svsJm>wu=lR3^g)1zTmX%q4 zKQnE$V@N?F8%s;>q`}|Hgigmx9Hsf9tvMhWP||K*IQ28TQBPXp2Ts<1qe-bzTVrKZ zkez`?_e?$x4g?pt=oh8;_sOekRRiNDi*;5k7!<;-ze3a?*t^Xxe#{IU;NzRUw4znM zZQ7O53*XWC#49z(O@lXeqzH73tfOP)eYj_?6)nc6EWEtT_2RnpyH5yo3wWeV0Wk1l zPN2em#C{zePr1sJnx4*e0%vQ7_M=1%$bcjZR&$?CT7X;@kjbvRcmNlbf2?3 zCv23!T%`h5-VglduPRgS@ffx|UTHDH%`$^y`3;{B8sGzDKX7q5dnu|oltoB&EL58< zZjFqjx7DaV1N3pv<(MI|c%#KVD15x$yk+Q4lC{&o;UjVE4-`R_U5NX?BO^Mfm)FPY zIF2t{a%!^?&SbGFsSw&QS-fk<^b1Wl4WA)yBwm*{>2auPFdMDw2XSD-ob!W3PT$YQ zH#Ignd+Dfj`s0Tx{@r);QZ?Hh;ZhzR2Dzz{^q@uG{rF*UyiE2_?RcBql&Ss3({Kv@*#_0JpUz}vyz<}^DEk4>3^^9;PjGPBkoLMTbHJUtXmN4W zW<#1+usHl!sPZRgu=O-`!We0$Gk6v${+Tj7$g2*A4FkZhGP-~4_1xW!6Z*Pk$xfxJ z`RVC8_$Vf%k3-@hw-}J_>UibmvFC%6^q1>fBOS5c3pI-ODyb@0k^qblwkl~!ieX?k ze&p-$kYS~&qVIfJAYW|QbMv&I5&{C|8z;xZcUyh&k_Djk<6|AZ_t8WU{`0BH;X%3; zz=N56#W0yyx&3#6xJRxq;eRlAw1jO=_U5j}6~(@$)YjL_o$N0FBWv#|_$5`bRJ+o? zy4nw0NU`v~`UsZljB$07d#{wpWt<^&Z2A!FX;DPP$NC~(U6p-v(bR|tok5}OEl~i9 z&wI6p=?c)J(KjRFe=5!q>`$@Oq?s+0yx#xy#2V#Og+9)S?f_Jq{dL7%KHfAkvdc$q z=$#*ubJ8LsCOopGsQEgqvVZXFLWz`l?W*7ng#j1F7?d@@z~tjN;J2eW)zZTFxZQVj zSb|z*6)+w>!4c0wO{o8b$oBluNdI?xLMdMce>AV=b;m~XJ;v1qW;c-NLxT%anMk#O z_lV0Uf?V%A`va!4Hl&3{u_czq=kJ#CUYL+5;GQx)#pAXD`xiJ{( zfzI_h8hrwysdaUA_xs;9kk+7{qJ~7Y1y%>Mp*xavev1|i$JajS27R8ZiY^)o77kI=8Nc`j8 zZQzYL=1FI%2Fbn$*^gPBB$NVlQWBQkKVC_H0*bzBB3E)j_!k&In`_|bTtEs%s}l3w8|{P(}Y@k^m~_uqf4>K0)6D*YaGA@ zPp6M+?CCkxQ1W1(2iMX(-wK?6?)%oR9Sfn*rsLx*f0ge(A` zo&@1aaq6*M2Z0JQ3@^i5o)AvqNlkG|kO;&))eL4F*iUiMdgh6b zEGygPLtZ2DdBk9r(KMHPUpMOiVb2(^HqfkV60KthoCc5(nK<7dMJvTv32%~R?1%NU z`)zXtB0){Xaxfs_5CmbY0tWq2Sai)Ipkqy`GRp}B1MkTQiiUYT{-xJ^oFkQIG>OVo zFtO$-@mnBL$%?Z&AI>QhhuqhE`AX~mZfV^}vBm;E#dB1Tb+e?~os%;|i$K^sZ(?PI zSFg(pzfZosAF2D)az_{2HuRE7hWb)IUr@m1n;j&{KgHz;a*@oJlyN*ZE%QjN zCER@@a;A*ge&g6zp9o_onOCm;8(Kpq8J9(n-N|IM5KF*&z%*-(IoQK}wAr>moEKrJp%Trm=VDbZE%;%3EKQe{jp}r}-3!y*1mh;QBKj*JbvDmmD z0!T-)J88_p=IOP+oodqB<|ika6uOq6f9b9q`X9^uxt_1O#U0S!#}Re}1-XkxcfRQd zQoJ%uHUC$mJnDS2DaMa{1f-*3o^@#36vlocSX`xSve>}Z0?_W(!pb!T%FClB6riya#oJcq7tJ#A5oCK>r`+;3F&JDo|F-3kZ!F^csaQw%S$mGc&5FdtDf1RX&X-%%!d+zy4fP z_-1Qw#0CR+S5{UsUR>j0vhH0}sK{0UQ!nFQuj=MEa`l+Z@?IoApcZhAf*ySsg3dL3pVglNi(tbe6mS>f_+arrdr_78nWo ztoF?;7ih1r`Ihhe*y-k(VI72R|IlXUf8JA+W#-U^hLc!DNC?{7ZfUWi#3C)z{+Dmn zrqv+e@4gj;tS7J7%QE{)Kd@3_^5MMt4B|o`PpTPY6h;~K55)WoGR(T!;XJgFCF6-_ zcM`#Yc*gz{NPEypfO~8w)3}LjDI^r7Y+|Um2HiJ`*YVyFQmiUhTNq_yUsuYL2iAWo zdG4lG{VG1V3q?ea(Q9ep8iBGcT6J--RXM@EY>xhdCqnYJ-%b8otLB<%AAIv1w z#jDKEppC{L-5+5~kwH6BFu}bA#_#pu){3d32yK0Z= zso*0@ms?8c>WgB|k)E=ijG{jGYI8r13r}mt4rj0b2V1fr5An-OQWZYWb7iy*26y0Hc zrDfDrZvf8+Os1F$VCM7=@3+XnN zU*eUL-|?7Da#88m!)!0iQmg{3D+n$9LnyvupJ6_)aMNX^15rxjM*KEGVf3_lH0v6t z{1hYe(WsvSz_aG&p{rZ#QMg-3WGiH?ep0D0}h#hSoMw2o*i_(Z{VP67WGYG0H2 zrXpLkF;bNGc+0!}j0NQ6M!N)iCTC_?M>Tmm2WuNgVcr`Z1?G%x^(D)gRK3!D=7Df3 zG_qcs?*vjz=DlMO;DMK0#`bH={$b>p69*y;pAP)#dPJ}0F_}5eUHj)ea$ePfW!&{u zlgCRSH)5Rg3tiSq2uv{J{eWNqsb6S|c7c1WymQI$ca&IkIVmhSNeqNn0b$6WhVrQ$ z-yP3$3kCuXtR(h}z*+ptKPbD&{U#Iw)!#S3(Gm*=?^{iQ|wsWj=1i4=XY%Ln!`-sYsYz?f_#RCB=sxb%m^GQEoPic&4|)Gj}P-q~@#R zB@qZG7RxV!#oSkThE`VCScD`%ZQ5U>T!PBcHtdB!)K+I%Zy)DX^HhAFioLFho)* zivk2jD!_*XX*fo`cz`>)Yk)XVCH@AGVn<&{ftBL91H9xq2IfO$N7W=!W4_^1k6nNM zL1VhuGaU#k+VZ<1iRb*a_4hd(S76j8-VdZ|-Kkv^B3DI)U-Zdgwx(|hEDpcY41+83 zu?6ycDEH83`2J_9$Tg^v5L`Uug~V3rsu{SmK=4CDt=s-Cn6i5V5U+nhIDN#P;uJp4 z#Htka3lb_BgA09Vxy9XC2yGMSG$R5r)bFB@i9|+2HqX8D4YaTC>B$qx`WJ0Wqu^;$T{BR^yM*3WQi{qJ!gQIDZO!R{Pyx~0HW1=N1Gc$qw^bY_r zYE&F^4 z181DoYW~pDzp8`R$k9nw6FQ4=QzUpmf>{jF|6Q!iE37aQi%7Z-eHAVGRV2gz9&t`O zIAf%w3`Hky6sKn|9?+B5LY&P{o>rP109sb~&p*5=$x=!8IL;F#bIbl*n@L}O7hW2? zz!TbD3X3Ef@_ILzUCE7vsXD%vm&i zt5fL7Qr#gQ8~*=kFy-nrXd#Ls^9e~?jw^W}KMK=+0JnjN=>6_%uzwehJ*9~0npG9F zdfil$Bm2L)9%QtksS+Vv4R&GQztATZ$|gonE(5J=-+z$EC;%aUqi5fO#A2^RV0!$e zQmeL=BOILjMmPXzQI@i)tOdyJgn;;DE66b~w#m*b9-bx#O-UL^IR1t2b@QP02#r8J zGtvd64e>WmC;p5G9Spe;eLs#EJ(P4QQ>98jlBcE8LcF<&b=K?#aW#kM~h_uREW@#lUg(qtR`UKFR) z2Le+$&XlH;8ysm!l_sw_y&lE?QI!tyWJ|nH2P)%%X#;Cv5TLP+ z%Xl~8DAsS%W(PB+)1ai7x=~5)b7-6l9#jN?>!GBM#C_hBLm%(|M&G9%Ykv41LLZ>w7$WX(y7Y=iMsg`8HAn%<;}oyM zQb>-_qb2^8BOX@;ZoI^?6Ws7J_lP!!?9KG*SWS`y{{ufNA?l*hPWWGfq0l4<=Jz~t z!04d#&2pjC)jF7ka5L zJ!Am<@D(#o(y6TOVnsr4KCt#nhSh8+X&hqD8d=4>3gI2Sjf_xN#@_-OBl*PR$`Bb= z82(y7`^bB-H>n^7)t|*w>ZO4Gs_>9i%0clpy-B|sc!74r07Dw4Y-}j;EM10Db%6^NM3UKXTX5odD zdlcVj!!&tDc^Yk5S6?3q_ltA;2OV|G`=gQjdkwib_V;hVsSfT!R903h2|J1Z{u(PY zcd25iGVM@>8~j@dqEupDj?_VvE8ia)G^e`H@Md!tLRRAeRbgtj`6=TC4YARF)34tO z3iDfa1MLwkFO?wV@gaS}$x+^w_v5aR#4K-n>J82Gjojvf&HfpNqn=Px8_!CS|0B;KK53A`pHDlz*qI zW?F{u6I#{8U8qySD(`=5`6aT}U?^m1N}?`kDxlK|R4*$S{+Cc9aVWxs6!85QALay6 zBIk!!ZBf6I>o=7Ne~2Bsm4~CYw`T%=HUC2KyUb0JRmEx_SH62)k|SOuoF8PoSo6(+ zkQzw)x*uhnjF{p6*xjS?AZ}ktZb_Xv8O! zS38D#W>^e?C{BvHJX2FhK32_?-ptAD57eeS6O1x`p|w^~*=m#g2>TlHSP{F%Ov&$7 zNzo5!j2X76q}-0qN@Qd-YE^Y$sI5lx0h;7Z`O@E-3;y$wbr)Gyv*DEK(#=1SY76L8 z-zP_TLw@mcUHs(5T#q|iUfRT~6@+9Ou|$t%rc8S6q>QVtaeyf+2IC72dQnLc`$yfQ zl#tpLQ&thO?VEX3{i@ICcBL@IW3LZ~+qK5X%(B!I)5h1wu?{P$MKilIiivYoYXnP~ z7uQ<#gv~q0bG~J6YFfR1QzN5I0VduW@+&-M|F;i@FQMabn? zMSU<`uiC`wc3#-STgpOb%8!9j^EJChCQYWkQ{rE8WJ>KZszT7~-(h-yizW!I&MprsGbcL+yHQ7gX)QJ{#-)|b$-O@(1bg^*1Y&-w1nKO@qMORG(v^Fx9T99pVYpvI9T(~1&y%>L)UIy#mw!F;P~HMKvEvR$aDO84ZC;79|j(fSsYupGM39eunOV2(16hD()DnT(>dBOQb z33kPzmLK1UuqD!k^P|omChe$vzoh%8P7@SSY!$g!+lHwlsI@fx{_)oO<>=#@PqVxK z%qJv#4Tm0vUAw-as{ZtJ4SuQS`X%@2iRs}Sly;ydgN^|N@Qb?_WO5#?Y@kTK3b0Ka zH6$Z+eju&l=%+lCECX=)RY0^jF>1Y&W_e90z0nGw9=lh-pgX=95&lz;3FLp;K)uT-Uw%r)y?K8FAd$uJJ6_dNF(MYPHO#8 z?}pMo!xpt03dPv+?#6tEFF8#sUYn3`F+f@&OELiC7Q**XX_^G<@M#=Mr+P=WOz`O^ z1I5hG%IAJdF%YI`WdgC3dPWkr%}Ve*$EzQzgtf=W02o;9<5Rja^%W{=%cfx&(B?MM z>mUK*nri{>PT`N|pGn!b`}iVcwlNX=PG>i?q++!rlrcUF=Fo}b1#9cv`o77Y29x4B zq|SbWj*$FO;F=>QNZ(N9n<<+Z(~k|0Rpu}={E?I=;|{o2Gv!o$aJe?neh|R?%`mjJ zzk!W_cSNBQsE_Eu8y=!Qi>#wGCh$6|xiUQWye0cf+)FG2B4-mv9_QF}8H9d1vPVVf>78QYkQ~7alL-@_=g2c1+U858Q1po ze`f&<#aD3E1K-3k#WV@2*o?NqpPJ6QyBr5&ZYJ-1Xswa((jY`Q~?IB(HR#08h^A8M~^ zE20_hder_kif!r?__ZNWr%HiL&u`m^*hP|e15r)-Jt75sv45+!*_N0-YhXKVo`ha+ zv%WGd^l;Gz@>EdOc|P(B%=m2KT7EX(Qref~y~l%UzM2mubmbX#c9&&^U*WU;f zRg6+q!}-n(e%9?AquzeN28Gh{%T*KaX-J2%)k0lOcr2*n%K3ydq7sXBuvybfS0xGU|v#iasDsAu9rm*q)tt`rPu0?}R zDPJK>8N!1ymBu=xO)qOzdU9C_@o8(}AWbh%lA4on{#pTe6(GHNOk{u7(%aO)R^2CC zR{W=p){eUVc6PNZQxf}a=%U}c_Z+6%Bx(@qf zN$B*b=(UEOYI1G1D=(1kAe$8qg~0EvSy2{%pNfu&ewtLe)jRidCy*%VuOUAWRAB5d z9bW2S36Bb4K4cK2%g(*!T{ojP>D1+tpe}#E<8ud_NB7@5n38 z)=)hnx=CHEB(CQ7t`~Zc1j*Y8HULhVz+=?HjhNb5F(M>t-M1`3uMs=EQ@*U%w2ER4 zSwU6q3w@&zdQ;NEd#^s5nUNX)jy!X2F|*|1UazU*sa>8|N6D8tB6O{Dmo3Xq8=7Gc z6&YFQG~eAB6%=X%;bM}p%oj^wuh;mDG3f3W6#upjsU2e_6;&^*&e80Y>ma1e80z!% zY`mwf-O=>BZX)iPE8hsO<560(%}*rS&R$SE)BbH2*E8vI5Vw#%2)>SVb5lIoWx--O z@|ElnOe6#-ayOHv`uh5#EjKGo1@esl@cXXPush^zW&zi0;iq7Bi^WXI-!ID2e~oE* z8qf1@#Yo_($Dw^H3ca!#i4winvzIvtj>Ws3!0eO8`?%^y84#e2VZIweK6!s{4SCwZ z|A6eX$&MkIJthHKpep-`$$8gj^xaXM#Ssl42zp@tl@9L0xgRamY9r}h3#v6rJTUQn z0sT>Vfz<~ZZ2SYybING(=J(WXmy! zBWyc||DKjIU&VRx7u2!_UMDS*`ePHK$+p5DTk5#v)sc>BQCi@lX*YdH=pddV> zYl_(Zr`pW*0jh6_sgR|2?i~ac-@`c&1AAL*;2~>o~Y>oLKcX zucuD}H&RAw1I8EUshS6Yn0$e|h`GY9Xm`&v*1GlEBL@k5DkUUprJ5{ur(G1&Ad`^#HrAgp`-gXvcC;f4M2pbRwPCOn~Yq!r%Mk@>wtTD+hb z)cPsAj}qX~fack`!RABzu31ZsD@v(D9;8f}kyu166!kJxIY6aAN1=}2So;qPvD~uq z^YgzkQaW|=zpPzQ-{u3Ph(CLwA__2IwSVPbp&UCw7}{xtg1Zq*pEDXaceGP5B+ju% zhp_z$O+#$|McIp-;V1&b!Y(bJtz5Hq;DFIcm{}7c;X}@1JdK*HO1GcjrOehW0#TLP z3g!!OmRcMs4oI8&xB1J@znSz~I1!VVq6hn{ShqMn68;2(foMK3AXCXAD3Y8QBm^|9 zJ#XYoR9lh~Q zgf;$N(X=g8*$rP+a`_!j+oj<_T^RX48$~_A_Ty|TYEo;Bn_qfN%l~Lo?T6bqbI~&( z1;H~ZpMLapb)fy=E+i#2$drc?6a-0;G&emBgz)*|>r`B&T&*Xnj42j7tg_l%z3_43 z1y)|^k4s?{g0R=xqx%8J8LHR~?D+aXJWT-#3dM6)d$+))8r6oRcaagXq?ocQ)U_m^ zl{A$jFW^IT->TH~hCr{~GYMfNpZval5S4mP6*L58>Id}{Gi1b^c7k-n*^UKom>Oa% zv0#rRjm?2@0mrGOC2bbwsNXsR+~d%IpB+X@K~(AAAggEW(j25d!lT1Ti6lVJXM!UX z`ZsYOZ}7PRU~QYNF0IHfGM*EM6d=FHrRD+jq+RuDY;yO47g%}16e2ZXua*!_ocl>*{lzTw;Mxm9ENW~_f$LXMt=c3u+DW zdmpe6DY%82hw{^$4D0T)^Q4t(y#O5ku@HCqJ_g*`?W%xL2y?a&U6y^wJtY=W!`|W) zO@0f2Gy{JZWUMe6Bm*u8Sw0y>0LsTvOl)swI28^uEIFu$0jv2#yR+0sICK~xmL%gz zoQwChg(x}nIaxnvwTYUHwq?Gw0k*F4Py+VgRV>xrm#a?JIlYgBw@cBa2OMsZ5%0Y;%;Oq-;$`Rq9$xZ0ZS?={)FLpp42M{B4{j?6U z#mJhJ`iO=uj8YWuEJzjzExi)c+oywgx9j5ZwCs8rJ=2NGmj)Pfx*gR+WQ0Y>5;0tE z1di^E9Ww%MnAzC8TZ@ZtgdkfW8dSndj*kv`h}wlXYRGfGl95V5Y{grid&p3W!2)Ky z4P7Haunm_{RA!J5f8BW-EsIy3q!Q`c0Dc$t1a(sH=;)MlB!nHij_OyBdo~Yj0`?y4 zk2ql{Itj((4<{$8-7$+11jhBfu{nz}fgk3#RR}34<_zuq1WyDO?*bK+w%q z_7impPIFma-ga`@0tWhaR&DLo2N>4vi5dP~*pH~_Fk(LV*}qp0uI`Q()7b4c`~eg$ zHrX!-eJAI*v3;SN2`51aEvRJ&fF#8f+rmG{fA+vy+^1$Mm;uq)AX>n&9xQ?LHtf5lW(&B;u{8>Nsb>YsS1xgEO)PA4tf`UW&2|lP7 zd$a7k>Z{l*>`%N3J9QHl5F-6WnE4X2*N%cRR-&l5n9Ffi#~C?+GlQ5`uhnCsz1;^P zu=DB6CC&dYqL|jk7b54hd>WX2D^fArkWF@njkDVkZCK2Ba^7bszKWOj=bM>n8Lx0a z`G85YBKx(2l()C{>iUs{Q9RgEso;I^)Q@(VZ2dNN7!FK4*0pmO6cgU&lfpt%p~Ld< zI;ySgb@QI-6>WNHZGz$@wbj^Vt44Vj&Yco+)7f!xjwV1oEbx(>>n z6-~zh5d7TW2;xQU{={&b%eb?0bujB3w}bo6!rB_;%IR9y5IKSW>^;96l=9%|?-Re~Up z#K(>8TX95lxp2CA8(E@ zE+Vhn^`D!}+h3K}z|$3Ta$eIih>oJy7VtA@5m#d+A$3c`_iUcN+=%J6MK@9lr_TX= zpa5>!F0f<0`nH)M>#*KUcd45&`^l*(#|VmA2?#j9yq1=hK|tKH8Frhj%UO8~-E}S& zTmAD7DqWorpF+icB6kYuTgkFgI9OQScj9#ZtTVMWHQb2@zqh~to!CYSuRK}E!q@x6 zP#r)?%k#v>Oz7tT;DGZ>6oN=qK47nW0NjzUJ(Cee-e9pm<`VRB;4%;$9`E0Y!Q=4^ zHO)XM!tH7E>%yuO0^~co8YO=C99`aeQYEe915(S-rrF40W9b9+2^a|C1DhrSBge)? z&|FJ3v+^73=o@LBD8rtAfy0i@X8G3+yG%L8-j`2pWvvOO$kh_dm_S3_lfK5%vjj&m zsPJ!RF3mjqUDuFFhXv{H+NyYhIV$Bo+m@EM3$KnZEZke@Sw#?CIKg;$#vuC-i+CZ@ zi=?Y_`G88W3A1k<4gwN#8NcYb&HpvnY}N5)6B>u#TdxnqY!mEkD?kG15Vu>DB7wDS zgt+u>E)%X61g2BhTkE-1%?g$l%VSl0eSAihbKJlyt7V;K8yMr`@!gpFX~p99d7lg( z?j{p7prM@LW$M+{72ieKh2`*GjreFWWiIgoPi0-ool^>-mbK^Fb@u@c9#=9`>9=IH!zNU}WRP ze)Nn>XzX7~B+tjzgF9~0>Z0V)%);;>xtfuMc+E0fd z6ta)vqjZmMq=z@vwUY+v3q!UX;VQLRSXk0`8{K}iw-We3pXZY^K+-}uB20PE;aS}W zfF9xn={oRu>8Cw3e4L5vzo!=|qk7*`r-RoyVAJ3H4lx3M$`^-#rVSHcoFjY4sNj)r zA|xgIa3W%frR+B^N|Lm*RJil|;~Br>eDhZu!s}hq0r(!imX_8_ikMz!K;-fHvnR$S z09Rx{kaNKW_ru{{u%Gi_))3qKZ!O8i$ z+3|KqCZo+WSw+a!zg-s{XoydIe>^iYLwRwcN(pt^3K9-nbx@2lXKqBKo&|}#%WFl- z==fg3if^)s9o_js%6DZBFS5SCLny?Xy%D=d7g?XS+&}*-3AIhrL+ALB>lKN;0o_s9 zxcdcey*7IUMucc;tFg{9X*)IMez+6^7U;!PpDExp_B$c=8V@|(IBgNw z{_eMQG}b}}#X%XxetKf*`KxpqRli8h5XH!^l8qsJ7`ED@=uV4RHYW=Pvi>Eu`K;Cgbc(eE_d6Mpb~>>TFtvvZvZ^R@&q{;AkC#2iCH4d-j zHBdWBh#$V>fo&lEh43eFFQjV2n3})PIvkjX`fY?uaJ+~2z^wZAKLztY;G1<}zpbvYIA1SXBh&e+=bITPw39&h|QtT zI~CwcFL|?zP`Sej$7B(Ma$3fX%SXw<{9an9bLxcfPOQh+;c9<+W}$-(VlKUtUpScn z+IISARyW2OYq(QN*27yJieVoKYIW+n%PUuSx@; z4sK6eMpZgPCMo}6z!U6gIhc^5-?mdVp{e;AC|b6^*QUYB`d8WlSW=3ZniE3*@OwoM zk}|2*o--2Z<{~% zLziY@(EGCCvMWGN*B%fKBT+5xw9sttA-8?>ygZukhr zW?sB-U4?yyJ@&5*47Vp7SYcn!iy^y&I)cgGAG=F^6wZPcReA0n%&V=94g}n4*KRqe z+W++R^$lgv2F^2m`QtVGNmEOUDDck#?e{*Q&gg@BcdwUB7PDB!?=me`@X0@f;D-oB zIE4{aaKl8wH*$AkrcgT)eOJtNMZ9z@X2eod5cVQJy!Q`BtX)U*XLk1)VP;tnhdlvm z9x)(auB1bQiE_iwRjI;u#5hfxk8m3O#UB+af_7{+29L;OB+|g~xACJnCaX%ZZw+~^ zl<-QG<6nC{tU-ca1e%IQeu(&=|0>2O!=g=g-+}Om&9H^05~JWvc1p3t?q_Vo7ldF# zs$_zDJBU9y0EAP~IM;ZIHt1V1`V$i8W#DWUWNU;px`;0Lr2LEVG*0*~Q@-~~;>7(z zebGv+43^U620y^|wy@@0gXHr$NHI`;1oi>0944xB#o=!G9{GSR{PDYn_bI!T=*Jv0 znO>NSe0{Gc7x9oGd#Z0|^>vLfAlgIe;~^_ZP+wjZ+jtna8x8EOyZ`B-oOz_uYb{NeI#T1w)%lzO@hBMYXLQD zWw#-y=%*mb!#9AMs}(V+8i4)tsNG_!xD1oz?t^(sI~B^#8HW+QPlwS6b_Ss1k~@ck6PGB|z`#;Z}8dF*?KN2_{aVY;39~2YP zVbOi5a{X;7@QE~g2xA6v?N`yJ?ZlMb?+w5CxtZy}MM4*p)C}sqh8};TAraIbY#YOTB{NJ6gSk0te^Gmt+Z>tpM|~d1dGeN!>{w+Pu?f z9142K^Ki@BB+GVz&hb|3V+DAMR_cW_w;Qqw>jiUDOW-GM147a*8v%qEYbT)ll8{5T zkS8>0r4CvuRg%b%Bv>a7Zt_%9DE%kLFWK_bhJdy!{KpNox{sDO(c0CPXvRMP6{{H4Fdv#9w+l|&!bsmGu|f4UhB=;XbORx~Jg&XFocuk3 z7TnK?=z6QDSv)$QdcV2l@_Q$2CTWP|j!R{+QwHWs1nJh70O#vfjerAk=7A@Fye+^b z>}n>v!A1e`c``wd>)(mIL2T=#-^b(1sNnCsR$$laqV*yg_#s3uu(%T+we2LY23&&lnBcEw`PqC5v_c9rE3odPRFAv{ z+9}hY z9Y=3e#9+g#w_lB$&;~3=FJ@osvamexbgd&1!o1%lc~7xiYEn4Fd#k@vQ)?CuIQ0>* zc8WZ2^RG@ziTbVeIGU289dSvOFE9%XtkV0Cwr*swl|qn02=8wUY=lFytFV(bmBS4z zf7*oMpiJov`T1_evA_Rzsd%*WcE4(%0168QSG(z)wwcYzZ6tW7awL-rchz-LM4jEt z9x#p-3EFZ@0&=K`U4RM-%ou%eTk)x9X5=!j<^H}Ojs~Zilb?IjeFl;K5V{B3jr+D& z_FGQ*rkNH(G#iu@DS2iNY3LtX%E0AoD)@OLp2yS9;2Gr7OqI2RhId%3Gn1o%0|Q2g z?tk-Tw0TntuI~fBg?~9qaIUj7Z=g{EGuz_I1@P~8$qKII_Ad08dkq|7`|%s{o}D#4 zGcE^OU;$p}rNGZEfXiDNtVL-56Vxh57dP2dHk;$X4FNt+8vDiiZ&SCt1(OSZGRu=g zLL!aCN&>r9z**5qA?7K?zs_!xM@!}OQ`?cUL-CCQLx?Pd7ft(>Va4zKIyXgdldmy} zBq)G4T)XZtXeq8}z)r*1@E_9gUVvb5)UYhs=`;AS^xU6dZf6%?LRNl=v~bAVZWecf zRg7)eai|}8nyQZ9k*MoT*y=WmF?VZhmgR{ZHZC5KDjR$E4&T9$Pn9@IW+%tReJ~(l z)wpGhG%+OSDSH1j)w=D;NslN2yvJFw+{zRFGcUd)%-{NV=i8Lv!kEsec6A-l7)n*sW}6M-wS@d-Ser~H?W!z-T#f@f6iR!E}~s!4TlVKdAL8EqC^JkDx&u}WSP;RD~P>bY94 z1@E9oM|Ftl*|E~4sp+zLPN0j(GNqEns8tpDodNQp&w4|YU2!K5-sc-3*dBlp$Dz?7 z>w8-OL5#hPS$_ZEBiv6}l`BuUY8;fzV&{}qC+hQ)hA`~N-dMyJD=c=KX^_g@haWkl z^7#->|UO3jAlpD_YMyQ*$H}T?!P7RdGpe>I5O@GNqBnQKL#M&u7xn2Zu32U z={uF$`6wmV|9h%7Hx~-rRwc@Cv!`)$cV}d04!Zv~$zU-&HhkQO+s<;pfm^1 z`#j)q+L~!4pq6~Hu3WhFRme1~pJtx64vR)LOzs^y{ps=;@h(runTto$W|t<+?;*9$ z^^jD`!zZo)e%scUpv$%iEF>xx=RTdZ&cTY_VEP88h%1h84K1y!YTxIM^3GLvS94q2 zQxm|<4l@;2H~?GhkIJH<>|ww+LLtY;b|e2_YCe3n zvgHpz!$`>ImC*2oNr&Jf? zNHl%#$%mbguKWnxP=arNDk4<=L9VL?)FA3D3sY?HpzEvu(}Yb2-S#0=4{S+`r;!D0 zDJ7*zSJoo6-BaA1vw(na8j%~+->UA)ObQI{yAJsdhEs{!QN2%vEEns(9I@1UynLY5 zcA;CjI(9bb@Pnb`Zap0O`}?M-Y+TFkssc@&t3NG#XE@ zN(NO^IBKj!f?J%Y>ojk|6pP^8ysEA&XwtMR98PtBM=e&%>~+ByvWY_R+(MYPwgN+bVQbuF-E zcXLg$8+e68%2DEk^^}yDnnkW9>V6-_sqJKK)MEh)2X}Ti>PeXS*hR@iks`)@zh~s~ z(&q7hJ$+?BR9)Bh(A`K&rvlO;EeO&GQqo;RgCIF{iwM$<64D*gF-Uhe2uR1!%)onm zZolvM?AftuuekO)pf$v(m)TKN&f4mBX7Z)pXE#<*MO0Qm_tK9ao8*lMVl$A3NH_2%HOEUSmA?E7X*E5A28_5hG(cn2>-0Ma4lbv4NiXj?$O4Drsc$dme|_>UBC)uVUQ-K_kCk7rpD>KxPw5LiFqeV z*a#FPWL?9=#k(dmMHRkq?Pa---fw=Y417BAXS^AeThx=0JHxD?!hwv4!K`Q{Pc{M^ zIB*?)!g(nK*Yx!Cl-HW--KQJwrEn{=UVdlt9vVqb9#09E6(&ywZ(Vj#Vfg3-_zRpa z;9oqiiQ>u7E3GUprqK4ZQy_(s&9L@nPAShu4XpHkEAbB?bopL!fK9HgC|EMCR_XBE zKK)WoVy|IzI7`e6dH$7-0mu|6PwQTPnvv`~``%jSM}`#hZi$yLN{(^tz36Oh+6Z+; zs^stb;!mIOmwgT#=kI29w%v8LC8GTAueLCx%0kDkABa~bH~rpailNP9WUBrV&f|fM zFKF=;)DcnbGdOZ0s)9tsL40GDJN-i2;<2Fv zIONFem-n8VqB85zTCKEud3r~9_MvLAcEEJII+{j0HBBjXrq+6- zWqRftzqy7=ox-L65NeXHi)Er>UB7)6)R)w+y%Jp+4}8{LJ0bC!(-YWQ`6#FU-p zIQq+%FL7~rsv~~}7kHS>hXH^>b>-vX+fMS-p=6tU`Bmb@z8G>0Dk>_q^Xd~zbalQc zR%CIkPG-iWPB|=07LZbBD&{4hV?T@e?6YUjtP3?uV5xf{y&`MO>^AP`oe;a`q&T*& zott1#g*cag6p0Y!qyJpIBU-w|Y=uz_Mj(vd>EV3D-^s*#Rq+#g2A$+1vmb}YOXP?4 zKv+(?1WKTOBT0O@*D>;9#F&&_r(?Xtm9RmOb$pxe^``F{Lh`un#OBu!wV%nUC|eu= zO~$USYVt>T|@a&U0ScxAOgHbbQYqcX=9GF(}X$`rk5P?D0<#UTq~o1U!NvI}lebEUxgO4c?RDmj%lg5uSXXI1E zjZj2J0i}zo6Kc!db6dD`*9dv%WAV6AMkZ4^z8CoJJWb0}|>!g9G zhlYN3a^3tG$D6jMW4Asqyn{A1RY?=sXMVFq_xM}SBwqa70KOyKaqPYnHpRAnJCZiy zWG~lb_b_Z0e?NVwb+%lH_!DW9EO)wGvW1TNCte(G@J(}+nGL>V5!jRedd_sYscWdj z(8cZUu+f+)G2_XLVPudBzjG|Cz%@~H6nY;jJ2gS7-Er4v7ibq*tRb3)56i9n)(q?z z4K2!BQ`E|vFKyV{dSw^(dL-%m&faUE_2~=DdnS1~E?M`+FdXt7uMZ!Lv7t6dcgzq! z>Y}rI_IlLLksewO8rh_MjqHWcOMq_ag`QPzSIAmNyms#hc81D@tCE@DpgiZwL#uMw z9^4kKegzHHw-8i2UTypsI5yT&L5|ckuVlaqHf#Vdm>Gn4bZz#<_~YS4bYw=d1=8op zGLay4#8N=jz6xazgYg?qs`~FPU*uL-PgJ)zwAVjbYP?<{6RZ{Rf7DTZ!6B_Uak@qn z{82K~U2`W;9g$PJvtwOmbYNJKbanMXZl6*1DyK9hO(ox2?8vX(Qq9EmI9_JZL@7!| z;mVU&?^aySdhv|7cKhAUNlv`mhj^-lI|mfVT)9EY8T441-gNilnUUK7OT+$D^zb`f z-G0V|U+IxVx8gmm#E`b$r@eF9`EI|hTd9Lm^+gw`Lfr07h6Plqv3|d!OLQwq;Mm^Y zw!!xzM6n+T0yF<~k1?ZgMgeo2vY68P7};G_JCkwF$}$gTA<|naa#rSDyd{E8Fqp?_ z@)kD-Zj64!)jY_&MpdEAUye#dnyz-gGWg=Vc{9vb7acsy78dj5lj?47fO6nmg+5M0 zqdISSUNScZ%#XsPn1;?0YoYBW@63c*Q>oqJ&K-D ztv5VMr-0iaqWQ zX_qdG{-vb?1F0DC;Hziit}%&6!KB>CVal~c62F?ZS3&msPW!dgnMvI{Dvv)qhw72M}0?k0FuLF|L@R^ z(Y;>S4!SD;*XuGQP@4VaB>E;5kA(QTR8{#It~xIcE@+Bb;Q>ln=0{8Q%mJ_T#WJG~ zoovI6pQM;f0aFZG{zP#(3>6v4rcwvXK&Qg6It!AsXg9=ZvMhI8T2dm44Rx?D4_|F8 zv0L2MFbqD1-Qw2sHpP%4%b5E}b=I|;)JkX&p0*mMRvc{kzu&hbWW^7x`{h{}C8oV( zDdBU9N8&9g^wPwyluPh>8WD6q5rCqlG2p` ztv#PM2^!?{+bYT^Ia=Do4@Lx13K0IZygLn(ZnTIm^hDmV_Tb({!Y!-1lJNIJDL<@V zKl>WJP#lqI5~Wm5{FQRXH;c#YmCUn}fN0k(sHj1P;yjr;lx`4)ag4f7eYL)-GNS3I zYpqt295FdRs^-lwIj#XDUB(FiJhS7QMhpw+I+|ggl$4Zw)XfVz_@(ZdX{o$sl*&Wb z83J7P!zYK4MrP$G@4wn*IkFM{QG*!Xs4=%nOTU?W{tUMOdQN;)Hb&~ftSQ?rA@cRK zu+frnVR!e+n{Oncxim1CK{%VuI^3@CadI)+>gm)h z#o%5`n?Q#})9``Wn&r$9TAG+Xuz#+zVIA*QKWR+gVXM%~mL%I4Q@%M#)=_)3?lD0YQi8oY`YMj2U#k-?GZ+9Zg$uK7Z|dr*^{oP2eA zYdZAnXKo<-qSr8qk#}}KH|f$D=Yd7UKfiIM-mmAS#XUt-*5E)$(0bsbI_T z;{#fR9N7j=sb$aZ?yjgdoZETZ>sqXx?6Bn=!lOg&rV78eIh(kPeX+)OJ~Q{h>$Qq5 zAD#3>p!V<_4o6!*<;VX~;lNb5hwq_ks-kOjH8_khwN}y|OO`Z+l|`{GJE$D?B^93@ z0kaIUwx5bvq|K0*_s8BP(yHBW0OM69y8YwdD1sH4Yphu!3#*oivnj7cm=L7Wf z`ajZyB5g+G8C-X0)?j%Y9g-!u*LWz9k~Dtcu|8@>b9m&}N9eqHxV;$5=Tr`V88E}) zcrNLwX9}Fc+xNs$boTJzncx@Sa~Nz6VrGXPDi{iCxY~|?i-S>Yo$T<-Xjp9_Sz^`e-S^OyKfhbv9~-Lt~M;6Ti(UIF@p2Sco5# z%4dZ=Ds~dmA0RnB8P!Pe`l(o8gFrpB>S+CbEBmGAvr)-=aR2BD?3NIF&+f$J`V$N* zDzg`GSR^iFRT{8seS>EX&Uh{6-&^(Ys!ol*Sd{7EnLN%jot=(RAyFGTY6&hpKafqj zJwW+qV)3tO|Sw_a+!#R$Eu zx7Sa5iv3Ad2o}WG2+F1puYSiYRTK(=#dy3sg`Ji~3k#XvM zKKodtk`_$u3|Cpa&+)S(7^aCIfBx2vZ=uCUl$%HyUbKbcCc{a#gv}nfH>TXDNm<^^ zDzDc@(rB4aL{tp1_S&Qma2q5gQ0~2I_8%I3?tK=TxX=x z?4&PoOsTt`8o;HMkKaiOZe(r{5O=p|m+Al`wqh{+$HpLkF9=FA-)x-XSCt^~V})<0(D z<^sLAT3``&IS2kDPm5PCR&%ensThZJG46%oA6~x>n;}Nd)^Bt&!jPucUgA9~I=Wi8 zWbyvvV-s>UP-k6y|1-w#L|5_!J3^Z%-Y&g?>W8l-rUlYk$HEc+*Y3E%ORFH}&xVzg z5dF4yc=z8t!mVNr4h5LT)t>i%O-?>W&(+xvciqW<9dmd%L&hkfg9A^!Gd8`@(maAi zR(CWse8|wu;Ea)D%;ss!))-B&j|>r=)Xo+(p=G-Q>UHZC>d4$^4lxHv3CH9 zMe{!vKbZzR5t_W@GHw--9yWRFhyfjvJt}%yhjmu`BPLzB+iJt1>jF*8G41Bb^M216 zM(g?*u~2ECUO)2z$|Cnth2o($kKEjF!dIOlWP0`SNh0ybP$V`KxeW5vr^zbz`&gQ( zhe_we_TxCA};>+g*F8*jcnGX`I+f(6MWY$yYt_g;-|3tvl8{dXO4*eRcIV_ zL`H`nKM;ejO7eS_S2G{q?NT$b+EQWjpC;O@No!T6rvT!$Rtcv)ZrZv+5`2x3n3584 zAo<~G!2KU45!mp>t>QzI4~FrY!xm$N!r#+=uraOO3h7Dkoc@A*%dIXQ5SnBi5xhN1I+JwN~YGXE>4NhOj?_SkCgBaUhNfmP;9G1A>g$@WwtnnE|NiLb zC`C(WZsJ(MxK4mOk3)eqwa{Cmq3_Ki5Wr4>`%nwC&h6V^u$B|vsVJX2xMrVoN8O|P zQ{C*o8{i7SaC%sAu)})|A0V{0CM+3 zjY-;n?>D=ykNA>G#tMQZ{uAUvY9{VMcb(r{y5n|?+fh7kA z4^!g({Cb?=W-~w4aQP2Z_)0Ms15rd~t`sq0T>>4oOv$)=8(j2Yb0{~S$gf^k>u3k* zaa5?CG%pFZsV0L!HmDF8^1|y7=~637i9hxTQ z>h%l2fQ--2>&d9(m_zaC4ZfyYl)Qsi>fm#7)7CZ!F3w{44sneMX~FG_Ia{MKiC96bw+%gSV9;Q7w&$m>l zPwM?lrZhp`*z{ndqN+T8Y%#F!Yj;HL`^sPxNbVq;ce*uPhqlhjc>J)F7iVM5nD1xK zZMyk}nOMK@B{xAR8m~j)syUeh4lG#Ke8`+=88-J7b)dKY0C?tHJ`QJ1&PjjVo{R z-@xFh=7BMX8(cl@dlbKB#jp2x$gL8Q24h!JZ?YRO~|;6TI!7E zhE8g}W+mS~2RtbPkKHN})*|e09W|wtCN~Il@p{+zBTzXnRS#mQ(R^U5vWd(VxwC!e z12fk#(#piTv0FKysO{H*8Lo4aT=R2fhKs*!n z8_9sJ3qhTK-npd9fMNskW58r%n2J%4^^UI3VXtSHn&kZRW^!`!oPt8lQi>DJ#mNgR zI<}IP=u}Dn+b}d+^KU^r;&8fJ`*WhNi~AF#>-YNjYZ*Xh3dy_wI|G&(CI534teP14 zUjZYuNp@JI@;Lk*>*Fpo-AZX=zLY4NV?ldwS;dhG6}sS3rtMF2sX@5e3z|eo48aX- z?{pp@B)imHO3G}K$en6YEwA`RU99lAbF)U|QXZVt^Uq0}FnV-qX^_GLZLqF49 zy)HAF&L+rD;XBvsAM}6C>Jbk$(okGAU7iS-JreoKShhkny)7|Odpj!oDMV)Fi75MVlwX3zpFxF43Kw5z(aNcdic>KpdCoyR z5ZwwDb90B4V%6%b)PPgVL$h$RN6Ko_d%&xwA=fKv(6fXCtm;bmIId%{83>e%{v@{Y z*d$L}%`MaRZ&82PI>Y}VY>o_}i?jHd!KJ7$cq2`(5)u6;^7}2Sxk*>&O zc4tsBK3IzIwXA^9Fr`8TaFMngtB!hkOOOdqPfyd#T%Nxmy5aDy(er?C_4S2GX*ya` z$n%k6uizD$H1o1o$}uKb98hP zN&Q&^SY@0}4&!($c3hp&Cdox!SWe{L0sXfZ2E0x1cYK!;pnf;h-^;^0rs+$Y-Ww~d z@HJ@L4PxKx?5Fn0=9q)m=E7Wyy_ye^EwZ!?W0>>1wrC6{XA1?{gKF(9UxLQ1_)@R+ z(m;PouBTY)(BwC1^ED^z*=umx2d^VFxRdrA>}nb+q4%@R^&Ox=b6C%xfIv@Z{(d81 zaDS+Mpi>jjCbFJl1V*akQI|VuL6}(p7(gsFXiDbTa_PHSN#+)%z)%!J(mev=S!9`C%)?#IyL6>rJVL z3*w6AO4_+)-T1M`02EqZGjelUw61*Rxi2y>pQ`t>zY@NcwI61f-epC|M!wo2@H)Y$ z?c<5HjIO6fYU)@Oj{#nC%;nv>2qLW-8QHYbVD4}&Ho00rWj4>ZhX{}k2Wbt0ISZab zjl=bcqT~)|i6p}#JFrr?sW8o+B>Yr1R8aCCd6>UyS6xjU*saR=tIe-EttyY0mf2tDhH= zisioR+f4gMm>FZ4PCrSll>1H@HNAqpNevRP`mP0aV}%hHwS!QknTbCl_tK&8{J2u1 z2zSk`tCO=?53t+~RtSdtWL4$XU$@M~^6-~ohN`;2U4Lbd1W@E!(PxwMGUk+(mwR5E zyd*AZBbSrlNY$S^iH`!pQiWIV&h|Fg~HGbT!?@I5C!GB66u}`0( z8tz=C`V8C*`2ri>{83u*Bg%_45Op(STsvd#FDDu1B7^sg|d)Sz8|$@joJ!GlHe@|L@n z9~$hWC{uJG6_-DCVJ#K+?p%rHv%C#NdC%SuF6+kh=x;s!Tl4W|VObaD%2`pRut=55>P9^@XnEo6h|6nsa?(aP*cE%QIC9 zZ{p6xZL94R-ZM{-Fls_kuU4P4v_q#bBlfq z35sWe313o33--eQ!0&F=Z8Rl&q5-q&1q$_O%MbqCf|rXu|C47{rjw84!rN}Ix9A6e zg)rLn@Vt?I-(0iv1hk>S?tvvO9CAiv`Cc~B6*D)`HUR#kp+V?*R5Bp8{5WKsB4U*4 z0Wm?;3Hn*Xs1RWgYC_LY8O{mTtRr+Fk7Dbv~xR{SGgi7}B;aWEw?%WV@A5TE(+v1WPpysFTWsQV7-F5r`1!$)~x z6Yriqp;qj02Cy1bTi5sfzz=BHI5^aY$xx!zzrc$Vpt%M$H6|)Fy-*RrhD7}KBwhG+ zuq{k<(}=A~#U#IC84DTX%T`lL=7*`0zJexXKn7g!*E~)6ShHxPe|?Fi`!E` ziG=Tnu)B6_0)IY~BNSd{8d`9D(qefX1nmg0Q!AO+e^SY zp&}1Ag0+Tr>A|kv#z(Dl4sQ=;0lEkkqh>TP;egn&@7|JLY$bi^W{7t8uZFqaC3$F*875AI;Q)Vq6>AKb_cUIU zvy7s@WX34*+Z*$N@K}Kfb+ZeNE#B+Ff)b%00auL}j17!u#G||CMlmZ>q9!Tam~;sx zq^uIJ{dn!}e4MU9!T!~v4$ z@%LGURK@1He*}Gk=A}>k~&Osbz||BiA;I z|84e-N?BbfS!V(e2#r+W%3~%F4H0Rt7+~1&Y~?>RI#97df8P?5V51ChScKeaLD6As zWat{C7uSmH{LLbmIfd=SjUuU8x$&4c6AEM0AJj_>&S8H4BhyKI7T}dR$?6Oal42a4 zj2$Z8OxO1}JikBPXb_<)sGjah9vzkCs-B)0^`_6}30YA^2B{rAI2%Gk$p1=Faqqg@ z_Z5TKufXkEv#S(IV=4N@!gO49u5jR^W3{ER0cTWO#L`s5TqI9BJpoBeZThDdzho8P zO0troYG{&nMs4+*TH8%PKJ+ap>V?#*Q5@*!E*Jp6|3$w6(Sl1`rAH7vyXR=$x9O>B zIj=w?+o!K}c1{O_^nP^`pDgb*g(N{e5(%0Z3V%fch4Xz~ajxK^ka9_ae2s}#B#o8C zynvY|I!CaIHI383kFML%yji5{F?OzQXG#A($WqLCEq|?O!Sua!Z9f2aswD;E)BchI zx5kls(R`?NXue|yq$Lswh*EcuDKv6@+2z1Z{8S8bg`8~m3{-yBQyk@4Q8LbBmL)~e zC0jT(lkra$=9RHPeHQ2hzYDS|=3ahHQ~k?C+)j>dpi{E4l9I8z70;{4*b)`$7AkNd zj!R9w4Zjg&jv|i1tOYjiFPADVB(i>0LQ+d|Q;751z`_Y5gW0nRm;#fRFhR3w;4>oq z)o;F`1RA36sVfCq1pkLK zrM{d%ER1wn3oThFew(yO_l!o(_}>dk25ePQy*rJ-53%WqEzt2*gD8Z9CoTE^$%}#LD9u0#^Na zUBKRP|By?^5_Ze3#9x~hXH~~z7jpj}3BKw5tsp_X+GryPyY-VpM)oU*oty4xw~Wxo zJRErTuE1A+url8X5MAoXG0G>%%m}p=+1URVN)t9j`vI;k;kTSrC7DoD?p+axC|k{;x1MxcY|0c4|S0 z6fs#vsoFHG4)vbUZpgXjaz(Dd^8vT2$2S<(S2*4%0eB{eas7(xwVeC-v}A3gz&7yC zUtF-a?(%%ad{nFY%y(&K_wkpW$?4{5! zlGH^lo6YwZ*75-NptBTLf?lQyvd>q2UPSK-wM76XpDBTgJ4+MYpG2bdqT!>m(ZT;) zm7nw)j9k_ifXDAG)@iXq@p&Nji2=T8UouL_stMt#7fU~7VnlUY;&$u+b*i+@@V(T% z;DO9Okad$=effJ@mTERe4F7KeW>h?H-i^9e%r+MP%c*S@^Bal&!sjoxB%?E;ddI}~ z4ga0es-Y08vgPM-1pQsbREX<|SwK}z%*Sf{h6I|H%nM z=r3A>*HkGw-1cmR2AQ<66j_m{BioH8U)wwf{+k+e%qq!oci)#W&~%+&4NpE+X()N6 z@C9muZ(77Z_KWrd_AXxf*-1yI_f$z&-l(9Pt)Z0A>_-8B37qWLwxg+S`?TtyR8EA$}m zKNd2y?#=@z+;y&;Pl{!Efv#}?j2rcdgEtu>|L?*9TvCF5z_1o0bY5$fJ<$z0!vpaO z-w`%LRFNfyX>wq2uDmScc=>-4Ax2{&zqF=(J)5P>afd>}?fLUXf&{8hiU7=grZN1W zjW*^#y<)s>q6H&&vJkW-=}uB1$awv6)}@8+NGlYHZg%_LpDt-PjwT=W{F4D0E0+1g zw`Yk@rVtOU&ips5pmy*T7tLFgO_m`ioQ|FUPr+uc(k|=xuYa0pHw0xDY7dwc|c=>m{C9>bzlaol4^Xf`; zFxM>}bp2zGe0(OJkne#K`|plC2WK|!aLbzd7^Fqq^^f7Vz2__&amEC1{u|2sGA`1z zRv4k1kPrW0I6%e4xbqrh?JZGA<3-r1gg$qpd0}`tC+pir`}yBKE~s6*tOIcZ-}|PQ z+**?i52=h>p&DY+|G8`u{{ot@=5aRNB=-kbR2plZh0lc$|HllPKzYBag|+{2j@VH& zM>>V*4`bpjC*vKcGqH^}qbD7-h`r8*ZhT49F;CQ2DsNRhbr6L0pHlV~;|NVnoW#Tu zFyC?#X5nqtb_#?*?0`y{2$pnvzwF@)r2Om7d7M*8$Ol4L11ZcvCa!_oh}izZ2l7v_ z6GmN0!1zV*hjfnj%U+DPJgWS>VOU#~6zZX8;138KQ*j6*avT~6eHV!x8AP}p(wuwm zkp+6$@=4|=dbH + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Godot BunnyMark + + diff --git a/benchmarks/bunnymark/images/bunny.svg.import b/benchmarks/bunnymark/images/bunny.svg.import new file mode 100644 index 00000000..b8b10f62 --- /dev/null +++ b/benchmarks/bunnymark/images/bunny.svg.import @@ -0,0 +1,34 @@ +[remap] + +importer="texture" +type="StreamTexture" +path="res://.import/bunny.svg-3356eb39f02eb923a7afbd5300694760.stex" +metadata={ +"vram_texture": false +} + +[deps] + +source_file="res://images/bunny.svg" +dest_files=[ "res://.import/bunny.svg-3356eb39f02eb923a7afbd5300694760.stex" ] + +[params] + +compress/mode=0 +compress/lossy_quality=0.7 +compress/hdr_mode=0 +compress/bptc_ldr=0 +compress/normal_map=0 +flags/repeat=0 +flags/filter=true +flags/mipmaps=false +flags/anisotropic=false +flags/srgb=2 +process/fix_alpha_border=true +process/premult_alpha=false +process/HDR_as_SRGB=false +process/invert_color=false +stream=false +size_limit=0 +detect_3d=true +svg/scale=1.0 diff --git a/benchmarks/bunnymark/images/godot_bunny.png b/benchmarks/bunnymark/images/godot_bunny.png new file mode 100644 index 0000000000000000000000000000000000000000..8cafbf9a2fa458c4b34245f96ec47cb563e86f77 GIT binary patch literal 1734 zcmV;%208hOP)<|C|22)8y zK~zY`wU%paT*Vc~|7Ygz^<#I9y~#R_wQ(Frgfx%_MbMO}Elny2A0mhZRD7sOa9i32 zRlE{FqEXYT6{2Y)J|IP@N~M;HLZDQkfFK5?K~QQ4CA3{Pm@F~Q+Uvdha=fp*_c5m* z*1O)dcjL5_^J(VJ%=yhZa~>C%6=v4r@#v6YObjx!#HWxeqR%pO%YwyNEP9J! zMAhLQ&U&O;}d@}jHoK>nfzvDO;iR_VvrpLCr{5zxwb@t5-RC<$z`x#LbO-zz`qU#Lw6DpH-p4t z6Awtqj{p#`7@T#$E+D!+w&RGNo}QkhC~xGe*kUhA3hXeDalmN@Pz->+olH*dYYvIt zE+sz##X?OxPzf7sGGH^ek}^XI2F&4}83(MOo2IjO{xXquFA=&_#s$m<=N$!RbX7sF z%PnlH#=fx`Jne!AI}(YpjWyORW5xi_xPaN@tOXELOI_4KH4iQ>x?o#LrQ}U>);PBi z=n~Gm%|nqHV9bGppa}wB-~fPv0+G08PKVmec^6O@4tv2!RY6M8*~PMjOALUnVk z7U3E;d6DcQIIbP3u}J?HX>{RJHiKREClVbi4a4w((F{Mm=KfA>47SfvJhBw*4;@?p0sxlsX@c|p$~>Gh z5zUovTyhnjA4wzB-Fj)h=mReS-iV0pDKe}j~tQPj(@a_bP}v z%5=(;7V+YDj>dTZ{{3PB=={0vgG7A#ju*~2!>K}k-*610nbJjrMl&Vs8;;@Kbiw}K zt7B0jKK-`;+F#Z+zUvPhzl{igz-J´{eTb>cK<>X;}Mna4qR$a%S`({h$|KA|u z2dkiCd%iYAz*Dt5T09bcOTExFv8Xm(6X;v&MTL%Sd_zco(1$%+S0I;;BhF9RmQ|ykQCM-Thr;vsrB4z8!^RS*;O0$#mGDb|L^(wQetM5-;L)g!0YhdML0%KjP61Wa2k ztIWT3?dr^?zCf1{AYoqbxkm|_sFT~e92i00B@hsVh6r)Wp~bUJ_>ksJ>b>bTQv~`gXR*JM(c_y0NnWK zoBootM*)1U+#toYuT{&n>zd_jl}?*SQ>Vt$YXGYJMyo4(1EWRT5joS<3YMeiOvh)t zYBu(1lDV|z*xqgVIuHO{ckuXCLg5tvOFmtNLjtUBc=ds=|GiP-0QzPv_0Mj}0!RTk3qqI_y useModule("com.github.raniejade:godot-kotlin-gradle-plugin:0.1.0") + } + } +} diff --git a/benchmarks/bunnymark/src/benchmarkMain/kotlin/BunnymarkV1DrawTexture.kt b/benchmarks/bunnymark/src/benchmarkMain/kotlin/BunnymarkV1DrawTexture.kt new file mode 100644 index 00000000..67efe12a --- /dev/null +++ b/benchmarks/bunnymark/src/benchmarkMain/kotlin/BunnymarkV1DrawTexture.kt @@ -0,0 +1,95 @@ +import godot.* +import godot.core.Variant +import godot.core.Vector2 +import kotlin.random.Random + +class BunnymarkV1DrawTexture : Node2D() { + private val bunnies = mutableListOf>() + private val bunnyTexture by lazy { + ResourceLoader.load("res://images/godot_bunny.png") + } + private val grav = 500 + private lateinit var screenSize: Vector2 + private val normalMap by lazy { Texture() } + + override fun _draw() { + for (bunny in bunnies) { + drawTexture(bunnyTexture, bunny[0], normalMap = normalMap) + } + } + + override fun _process(delta: Float) { + screenSize = getViewportRect().size + + for (bunny in bunnies) { + val pos = bunny[0] + val newPosition = bunny[1] + + pos.x += newPosition.x * delta + pos.y += newPosition.y * delta + + newPosition.y += grav * delta + + if (pos.x > screenSize.x) { + newPosition.x *= -1 + pos.x = screenSize.x + } + + if (pos.x < 0) { + newPosition.x *= -1 + pos.x = 0f + } + + if (pos.y > screenSize.y) { + pos.y = screenSize.y + + if (Random.nextFloat() > 0.5f) { + newPosition.y = -(Random.nextInt() % 1100 + 50).toFloat() + } else { + newPosition.y *= -0.85f + } + + } + + if (pos.y < 0) { + newPosition.y = 0f + pos.y = 0f + } + + bunny[0] = pos + bunny[1] = newPosition + } + + update() + } + + fun add_bunny() { + bunnies.add( + arrayOf(Vector2(screenSize.x / 2, screenSize.y / 2), Vector2(Random.nextInt() % 200 + 50, Random.nextInt() % 200 + 50)) + ) + } + + fun remove_bunny() { + if (bunnies.isEmpty()) { + return + } + bunnies.dropLast(1) + } + + + fun finish() { + emitSignal("benchmark_finished", bunnies.size) + } + + companion object : GodotClass(::BunnymarkV1DrawTexture) { + override fun init(registry: ClassMemberRegistry) { + with(registry) { + registerMethod(BunnymarkV1DrawTexture::_draw) + registerMethod(BunnymarkV1DrawTexture::_process) + registerMethod(BunnymarkV1DrawTexture::add_bunny) + registerMethod(BunnymarkV1DrawTexture::remove_bunny) + registerMethod(BunnymarkV1DrawTexture::finish) + } + } + } +} \ No newline at end of file diff --git a/benchmarks/bunnymark/src/godot/gdnlib/Benchmark.gdnlib b/benchmarks/bunnymark/src/godot/gdnlib/Benchmark.gdnlib new file mode 100644 index 00000000..dccfed27 --- /dev/null +++ b/benchmarks/bunnymark/src/godot/gdnlib/Benchmark.gdnlib @@ -0,0 +1,18 @@ +[entry] + +X11.64="res://build/bin/benchmarkLinux/debugShared/libbunnymark.so" +Windows.64="res://build/bin/benchmarkWindows/debugShared/bunnymark.dll" +OSX.64="res://build/bin/benchmarkMacOS/debugShared/libbunnymark.dylib" + +[dependencies] + +X11.64=[ ] +Windows.64=[ ] +OSX.64=[ ] + +[general] + +singleton=false +load_once=true +symbol_prefix="godot_" +reloadable=true diff --git a/benchmarks/bunnymark/src/godot/gdns/BunnymarkV1DrawTexture.gdns b/benchmarks/bunnymark/src/godot/gdns/BunnymarkV1DrawTexture.gdns new file mode 100644 index 00000000..4c34b213 --- /dev/null +++ b/benchmarks/bunnymark/src/godot/gdns/BunnymarkV1DrawTexture.gdns @@ -0,0 +1,6 @@ +[gd_resource type="NativeScript" load_steps=2 format=2] +[ext_resource path="res://src/godot/gdnlib/Benchmark.gdnlib" type="GDNativeLibrary" id=1] +[resource] +resource_name="BunnymarkV1DrawTexture" +class_name="BunnymarkV1DrawTexture" +library=ExtResource(1) diff --git a/benchmarks/gradle/wrapper/gradle-wrapper.jar b/benchmarks/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000000000000000000000000000000000000..f3d88b1c2faf2fc91d853cd5d4242b5547257070 GIT binary patch literal 58695 zcma&OV~}Oh(k5J8>Mq;vvTfV8ZQE5{wr$(iDciPf+tV}m-if*I+;_h3N1nY;M6TF7 zBc7A_WUgl&IY|&uNFbnJzkq;%`2QLZ5b*!{1OkHidzBVe;-?mu5upVElKVGD>pC88 zzP}E3wRHBgaO?2nzdZ5pL;m-xf&RU>buj(E-s=DK zf%>P9se`_emGS@673tqyT^;o8?2H}$uO&&u^TlmHfPgSSfPiTK^AZ7DTPH`Szw4#- z&21E&^c|dx9f;^@46XDX9itS+ZRYuqx#wG*>5Bs&gxwSQbj8grds#xkl;ikls1%(2 zR-`Tn(#9}E_aQ!zu~_iyc0gXp2I`O?erY?=JK{M`Ew(*RP3vy^0=b2E0^PSZgm(P6 z+U<&w#)I=>0z=IC4 zh4Q;eq94OGttUh7AGWu7m){;^Qk*5F6eTn+Ky$x>9Ntl~n0KDzFmB0lBI6?o!({iX zQt=|-9TPjAmCP!eA{r|^71cIvI(1#UCSzPw(L2>8OG0O_RQeJ{{MG)tLQ*aSX{AMS zP-;|nj+9{J&c9UV5Ww|#OE*Ah6?9WaR?B04N|#`m0G-IqwdN~Z{8)!$@UsK>l9H81 z?z`Z@`dWZEvuABvItgYLk-FA(u-$4mfW@2(Eh(9fe`5?WUda#wQa54 z3dXE&-*@lsrR~U#4NqkGM7Yu4#pfGqAmxmGr&Ep?&MwQ9?Z*twtODbi;vK|nQ~d_N z;T5Gtj_HZKu&oTfqQ~i`K!L||U1U=EfW@FzKSx!_`brOs#}9d(!Cu>cN51(FstP_2dJh>IHldL~vIwjZChS-*KcKk5Gz zyoiecAu;ImgF&DPrY6!68)9CM-S8*T5$damK&KdK4S6yg#i9%YBH>Yuw0f280eAv3 za@9e0+I>F}6&QZE5*T8$5__$L>39+GL+Q(}j71dS!_w%B5BdDS56%xX1~(pKYRjT; zbVy6V@Go&vbd_OzK^&!o{)$xIfnHbMJZMOo``vQfBpg7dzc^+&gfh7_=oxk5n(SO3 zr$pV6O0%ZXyK~yn++5#x`M^HzFb3N>Vb-4J%(TAy#3qjo2RzzD*|8Y} z7fEdoY5x9b3idE~-!45v?HQ$IQWc(c>@OZ>p*o&Om#YU904cMNGuEfV=7=&sEBWEO z0*!=GVSv0>d^i9z7Sg{z#So+GM2TEu7$KXJ6>)Bor8P5J(xrxgx+fTLn1?Jlotz*U z(ekS*a2*ml5ft&R;h3Gc2ndTElB!bdMa>UptgIl{pA+&b+z_Y&aS7SWUlwJf-+PRv z$#v|!SP92+41^ppe}~aariwztUtwKA8BBLa5=?j3@~qHfjxkvID8CD`t5*+4s|u4T zLJ9iEfhO4YuAl$)?VsWcln|?(P=CA|!u}ab3c3fL8ej9fW;K|@3-c@y4I;^8?K!i0 zS(5Cm#i85BGZov}qp+<-5!Fh+KZev3(sA2D_4Z~ZLmB5B$_Yw2aY{kA$zuzggbD{T zE>#yd3ilpjM4F^dmfW#p#*;@RgBg{!_3b6cW?^iYcP!mjj!}pkNi{2da-ZCD2TKKz zH^x^+YgBb=dtg@_(Cy33D|#IZ&8t?w8$E8P0fmX#GIzq~w51uYmFs{aY76e0_~z2M z(o%PNTIipeOIq(H5O>OJ*v8KZE>U@kw5(LkumNrY>Rv7BlW7{_R9v@N63rK)*tu|S zKzq|aNs@81YUVZ5vm>+pc42CDPwQa>oxrsXkRdowWP!w?=M(fn3y6frEV*;WwfUV$s31D!S_;_~E@MEZ>|~wmIr05#z2J+& zBme6rnxfCp&kP@sP)NwG>!#WqzG>KN7VC~Gdg493So%%-P%Rk!<|~-U|L3VASMj9K zk(Pfm1oj~>$A>MFFdAC8M&X0i9-cV7Q($(R5C&nR5RH$T&7M=pCDl`MpAHPOha!4r zQnYz$7B1iLK$>_Ai%kZQaj-9)nH$)tESWUSDGs2|7plF4cq1Oj-U|+l4Ga}>k!efC z*ecEudbliG+%wI8J#qI!s@t%0y9R$MBUFB)4d47VmI`FjtzNd_xit&l1T@drx z&4>Aj<2{1gUW8&EihwT1mZeliwrCN{R|4@w4@@Btov?x5ZVzrs&gF0n4jGSE33ddUnBg_nO4Zw)yB$J-{@a8 z);m%fvX2fvXxogriNb}}A8HxA)1P-oK+Da4C3pofK3>U_6%DsXFpPX}3F8O`uIpLn zdKjq(QxJTJ4xh->(=lxWO#^XAa~<7UxQl8~8=izS!TcPmAiBP5Et7y?qEbFd9Q=%IJ;%Kn$lto-~3`}&`x=AVS+Uo7N*hbUxhqVH_w^sn!74z{Ka#*U6s z=8jIrHpUMBC@@9Jn~GS<$lse*EKuX%3Swl5&3~GiK_$vn8Vjqe{mjhBlH}m4I8qK+ ztU50COh7)d-gXpq-|}T;biGa^e=VjxjjFuoGIA8`2jJ}wNBRcsx24?7lJ7W4ksNPv zA7|gcXT@~7KTID#0|EX#OAXvgaBJ8Jg!7X#kc1^Tvl;I(=~(jtn-(5bhB=~J^w5bw z8^Hifeupm;nwsSDkT{?x?E(DgLC~Nh8HKQGv`~2jMYrz9PwS^8qs3@nz4ZBCP5}%i z=w}jr2*$X-f(zDhu%D8(hWCpix>TQpi{e`-{p^y?x4?9%)^wWc?L}UMcfp~lL|;g) zmtkcXGi9#?cFOQQi_!Z8b;4R%4y{$SN~fkFedDJ&3eBfHg|DRSx09!tjoDHgD510Z z_aJLHdS&7;Dl;X|WBVyl_+d+2_MK07^X1JEi_)v$Z*ny-()VrD6VWx|Un{)gO0*FQ zX{8Ss3JMrV15zXyfCTsVO@hs49m&mN(QMdL3&x@uQqOyh2gnGJYocz0G=?BX7qxA{ zXe0bn4ij^;wfZfnRlIYkWS^usYI@goI9PccI>}Ih*B!%zv6P$DoXsS%?G)|HHevkG z>`b#vtP=Lx$Ee(t??%_+jh(nuc0Q&mCU{E3U z1NqNK!XOE#H2Pybjg0_tYz^bzX`^RR{F2ML^+<8Q{a;t(#&af8@c6K2y2m zP|parK=qf`I`#YxwL=NTP>tMiLR(d|<#gEu=L-c!r&(+CpSMB5ChYW1pUmTVdCWw|!Ao?j&-*~50S`=) z9#Knf7GPA19g%Y7wip@`nj$aJcV|SakXZ*Q2k$_SZlNMx!eY8exF;navr&R)?NO9k z#V&~KLZ0c9m|Mf4Gic}+<=w9YPlY@|Pw*z?70dwOtb<9-(0GOg>{sZaMkZc9DVk0r zKt%g5B1-8xj$Z)>tWK-Gl4{%XF55_Ra3}pSY<@Y&9mw`1jW8|&Zm{BmHt^g=FlE{` z9Lu7fI2v3_0u~apyA;wa|S4NaaG>eHEw&3lNFVd_R9E=Y? zgpVQxc9{drFt2pP#ZiN~(PL%9daP4pWd*5ABZYK{a@e&Vb`TYiLt$1S>KceK36Ehz z;;MI%V;I`#VoSVAgK3I%-c>ViA>nt=5EZ zjr$Jv~$_vg<$q<@CpZ1gdqP_3v^)uaqZ`?RS_>f(pWx3(H;gWpjR?W8L++YPW;)Vw3)~tozdySrB3A2;O<%1F8?Il4G|rO0mEZYHDz!?ke!$^bEiWRC1B%j~ws0+hHS;B8l5Wh)e+Ms7f4M4CbL%Q_*i~cP}5-B(UkE&f7*pW6OtYk5okQCEoN4v|7;(+~~nyViqo5 z(bMGQi$)KN6EmfVHv4pf2zZMJbcAKyYy>jY@>LB5eId|2Vsp{>NMlsee-tmh({;@b z@g;wiv8@a1qrDf-@7$(MR^M^*dKYBewhIDFX%;*8s zR#u?E;DJO;VnTY6IfbO=dQ61V0DisUAs4~t|9`9ZE(jG}ax#-xikDhsO_4^RaK ziZ?9AJQP_{9WuzVk^s_U+3V8gOvVl5(#1>}a|RL>};+uJB%nQM-J>M4~yK)cioytFXtnmOaJZSiE+3g}C`Im~6H z*+-vjI>ng5w>>Y!L(+DwX2gs0!&-BFEaDie4i5ln*NGP$te7$F9iUlJl4`XpkAsPm z0l?GQ17uN^=g~u1*$)S`30xL%!`LW*flwT*#svAtY(kHXFfvA`dj*pDfr0pBZ`!La zWmX$Z@qyv|{nNsRS|+CzN-Pvb>47HEDeUGFhpp5C_NL0Vp~{Wc{bsm_5J!#tuqW@? z)Be zb&Gj&(l*bHQDq7w-b`F9MHEH*{Dh~0`Gn8t`pz}!R+q~4u$T@cVaUu`E^%0f-q*hM z1To6V31UGJN7a-QW5;nhk#C26vmHyjTVZkdV zqYMI9jQY)3oZt=V0L7JZQ=^c2k){Y_lHp&V_LIi*iX^Ih3vZ_K<@Di(hY<&g^f?c$wwF-wX1VLj>ZC4{0#e`XhbL_$a9uXS zKph*4LupSV2TQBCJ4AfOXD8fs2;bAGz-qU4=Qj$^1ZJX z2TtaVdq>OjaWGvv9)agwV)QW9eTZ-xv`us2!yXSARnD5DwX_Vg*@g4w!-zT|5<}-7 zsnllGRQz>k!LwdU`|i&!Bw^W7CTUU3x`Zg8>XgHj=bo!cd<#pI8*pa*1N`gg~I0ace!wzZoJ)oGScm~D_Sc;#wFed zUo;-*0LaWVCC2yqr6IbeW3`hvXyMfAH94qP2|cN``Z%dSuz8HcQ!WT0k38!X34<6l zHtMV%4fH5<6z-lYcK;CTvzzT6-^xSP>~a*8LfbByHyp$|X*#I6HCAi){gCu1nvN%& zvlSbNFJRCc&8>f`$2Qa`fb@w!C11v1KCn)P9<}ei0}g*cl~9A9h=7(}FO!=cVllq3 z7nD)E%gt;&AYdo{Ljb2~Fm5jy{I><%i*GUlU8crR4k(zwQf#nima@xb%O71M#t-4< z(yjX(m^mp_Y;5()naqt2-VibylPS)Oof9uBp$3Gj`>7@gjKwnwRCc>rx%$esn);gI z5B9;~uz57n7Rpm8K^o=_sFPyU?>liHM&8&#O%f)}C5F7gvj#n#TLp@!M~Q?iW~lS}(gy%d&G3p?iBP z(PZQUv07@7!o3~1_l|m5m;Xr)^QK_JaVAY3v1UREC*6>v;AT$BO`nA~KZa1x3kV2F z%iwG7SaaAcT8kalCa^Hg&|eINWmBQA_d8$}B+-Q_@6j_{>a- zwT3CMWG!A}Ef$EvQsjK>o)lJ;q!~#F%wo`k-_mT=+yo%6+`iGe9(XeUl;*-4(`G;M zc@+ep^Xv&<3e7l4wt48iwaLIC1RhSsYrf6>7zXfVD zNNJ1#zM;CjKgfqCabzacX7#oEN{koCnq1-stV+-CMQ=ZX7Fpd*n9`+AEg9=p&q7mTAKXvcbo?$AVvOOp{F>#a;S?joYZl_f}BECS%u&0x!95DR;|QkR9i}`FEAsPb=)I z8nb=4iwjiLRgAF}8WTwAb^eA>QjL4Srqb#n zTwx^-*Z38Uzh@bX$_1tq>m{o8PBX*t3Lqaf$EBqiOU*2NFp{LJX#3}p9{|v{^Hg4f zlhllKI>F+>*%mu6i9V7TT*Wx-zdK z(p8faUOwGOm5mBC%UGA1jO0@IKkG;i&+6Ur8XR2ZuRb$*a}R^-H6eKxcYodlXsF`& z{NkO+;_Yh-Ni@vV9iyzM43Yibn;oC7hPAzC24zs&+RYdY&r`3&&fg2hs62ysV^G`N zHMfBEFo8E3S$0C_m({bL8QCe$B@M{n1dLsaJYIU;(!n*V?0I1OvBB=iYh&`?u8 z&~n-$nbVIhO3mMhCQRlq%XRr1;Hvl=9E_F0sc9!VLnM>@mY~=Cx3K5}wxHKEZF9pC zIdyu1qucM!gEiomw7bW0-RwbX7?o=FE#K0l4`U2KhC8*kMWaEWJyVNZVu_tY2e&4F zb54Lh=Oz>(3?V$!ArXFXh8Cb3i;%KQGCrW$W#;kvx$YA2gofNeu?@nt>Yq8?2uJQp zUTo14hS%&dHF3Uhm~Z1>W)yb%&HoM!3z?%a%dmKT#>}}kKy2B=V3{Nu=bae%V%wU$ zb4%^m?&qn==QeHo`nAs3H}wtiK~!!&i|iBLfazh6!y9F)ToKNyE0B385!zq{p)5vB zvu`R#ULIS|2{3w52c*c$4}Pe>9Fw&U^>Bb_LUWn!xPx3X-uQsv(b1XFvFzn#voq0* z5~o`V_G805QXdgAOwOjoqmZ?uzwBVYSNP0Ie8FL`P0VK1J4CzV@t&%0duHB{;yIL$FZ9 zz#s#%ZG6ya&AwE;0_~^$1K

Hnj76Oym1QVh(3qRgs)GmgnEt-KxP|nCFY3uezZn zmtR0CZ$Z_-+f07?lu_tr~IC{&U6+QOth>ZgYk4V2FI$B2V3`M`Jk zsr>>lupymPeK129PfpDt9?GA2;I>03Ktz8NxwvTroqu8oaRB&bXT}G=^2UyOW}(4H z;9sG^YwV8K7pC&&viM^X_pfeFoN!cIhrE>OPQ5E<4KKDyPhRV^BGb_^Y6GO6#w}c= zu`0fC-@F4qXQtnB^nPmfI7Uw0bLhY^09TCO+H2(nvg8jdPjMAi4oSX%GP3oeo0`ks z%DoV|waU-Q7_libJCwnnOL9~LoapKqFPpZx?5FygX zsA~*ZR7X=@i{smf?fgxbcY6Y`JvD50P=R;Xv^sANPRp-Hc8n~Wb*gLIaoZJ2Q^CFe z_=G}y&{_NXT|Ob??}$cF7)$oPQMaeN_va1f%>C>V2E01uDU=h~<_fQKjtnl_aho2i zmI|R9jrNdhtl+q*X@}>l08Izz&UJygYkbsqu?4OOclV{GI5h98vfszu2QPiF?{Tvh19u_-C^+NjdAq!tq&Rd`ejXw#` z@U15c$Nmylco)Yj4kctX{L+lz$&CqTT5~}Q>0r-Xe!m5+?du6R&XY|YD5r5C-k*`s zOq-NOg%}RJr5ZWV4)?EO%XzZg&e8qVFQ?40r=8BI-~L%9T7@_{1X@<7RjboXqMzsV z8FiSINMjV*vC^FCv_;`jdJ-{U1<_xjZg4g?ek z4FtsapW_vFGqiGcGHP%?8US~Dfqi8^ZqtHx!}0%dqZFg%nQB)8`mE$~;1)Fb76nFk z@rK#&>2@@)4vO&gb{9&~R8-_{8qz6Rmw`4zeckD(L9xq}{r(fUO0Zh-R(d#x{<0j| z?6xZ2sp3mWnC}40B~g2QinHs1CZqZH&`+x2yBLT8hF7oWNIs_#YK2cyHO6AoGRG|RM>Hyn(ddpXFPAOGh~^0zcat`%&WoEQf9)!@l*3Tt@m>Lb z6$+$c!zsy_=%L9!_;jfd`?VXDd*^Vn%G>n~V9Vr6+_D@#E+dWB#&zAE+6xJeDMr1j zV+Tp~ht!M%^6f?)LBf8U1O4G#CutR07SB>8C&_&;g3TdIR#~e~qRtwd>&)|-ztJJ#4y0|UMjhJZlS8gA zAA260zUh+!$+xMfWKs|Lr23bcy#)JNnY|?WOka&wTS7_u%*N7PrMl1Lp9gxJY%CF? zz4IA@VVxX{knZPlNF+$9)>YIj#+(|$aflt=Wnforgn6`^3T+vaMmbshBjDi&tR(a7 zky~xCa77poRXPPam)@_UCwPdha^X~Aum=c0I@yTyD&Z!3pkA7LKr%Y6g%;~0<`{2& zS7W$AY$Kd}3Tg9CJgx=_gKR59zTMROsos?PU6&ocyCwCs8Qx1R%2#!&5c%~B+APu( z<1EXfahbm{XtOBK%@2a3&!cJ6R^g|2iLIN1)C2|l=;uj%tgSHoq2ojec6_4@6b<8BYG1h-Pm_V6dkRB!{T?jwVIIj&;~b7#%5Ew=0Fx zc(p7D1TT&e=hVt4spli}{J6tJ^}WL>sb`k}&gz+6It`Yz6dZdI53%$TR6!kSK2CfT*Q$`P30 z;$+G$D*C$U(^kkeY!OWn$j@IUu0_a{bZQ=TCbHD1EtmZ0-IBR<_3=tT%cz$>EE!V}pvfn7EMWs^971+XK}~kxSc_ATJJD$?)1Gz^Jq!>Hz#KkdCJ~jb-Y*Xv01_}}=T_V-A1<3O!V9Ezf z%Lnjihb3>=ZV}jSeqNu5AAdVbe|`;|p<%W#-<$s1oDYrB;C({psqV>ENkhadsC{cfEx=teVSB`?FOs+}d#pssxP z(ihudAVu3%%!*vOIWY11fn1M0&W|(|<2lEShz|#%W|wV2qM%#+P9NOy1x8jytHpfU zh;_L^uiL<<$L@~NpRXSrkJgdC>9R=>FmVu3^#C?3H>P{ue=mcv7lBmnfA?mB|L)EF zHv%Nl|D}0Tb~JVnv$ZysvbD8zw)>|5NpW3foe!QHipV9>Zy`|<5?O+rsBr*nZ4OE} zUytv%Rw7>^moSMsSU?@&a9+OdVgzWZnD>QXcUd{dd7vad+=0Hy)4|0A`}rpCx6cu!Ee5AM=iJ?|6=pG^>q(ExotyZP3(2PGhgg6-FkkQHS?nHX(yU0NG;4foCV|&)7 z1YK!bnv%#5n<25|CZ>4r1nK=D39qMzLAja*^#CN(aBbMx${?Iur3t=g2EMK|KwOF?I@W~0y`al&TGqJ zwf#~(?!>@#|JbDjQV9ct%+51l%q|lcY&f{FV&ACRVW*%VY6G5DzTpC!e%=T30mvav zRk$JOTntNoxRv>PDlJG1X=uep&???K00ep|l_#7=YZPuRHYoM46Z$O=ZZuGy_njgC z>P@gd+zKH5SjpWQ!h_r*!ol1s{9DS@sD4}xgFxaw>|av!xrKzg?rGnhZ#uZeU~iod z3-i*Hl@7cge0);y{DCVU(Ni1zg{yE&CxYT7)@zJ%ZZABj-Fh}0au^)*aw`vpmym;( z5|JZ!EACYenKNXH%=Md{my$sI3!8^FgtqkMcUR%w_)EBdP5DZ64aCIR%K99tId6SU ziT8Ef)K%7{XuIpPi}N+&FCm$elE>oKY;3c$x+*mXy?~wt6~?ss$HGqCm=YL2xzVTQ zr>*2_F;7j{5}NUPQ(aY0+h~rOKN|IA28L7^4XjX!L0C^vFB+3R5*1+s@k7;4d#U=5 zXTy8JN^_BCx1a4O3HMa9rf@?Fz>>dq}uvkY7!c?oksgs~xrpCo1{}^PD?w}Ug z3MbfBtRi z$ze~eRSLW^6bDJJeAt^5El{T*i1*v9wX{T7`a2wAVA z%j>3m*g^lc*~GOHFNy?h7>f7mPU*)3J>yPosaGkok}2#?wX5d$9moM~{NTzLznVhX zKa}bFQt#De`atoWzj4Lb@ZCud_T9rA@6VcmvW(+X?oIaH-FDbEg#0Slwf|7f!zUO( z7EUzpBOODL&w~(tNt0z|<9}Filev&4y;SQPp+?kIvJgnpc!^eYmsWz1)^n`LmP&Ui z-Oi1J2&O|$I<^V@g2Z91l3OArSbCkYAD0Tuw-O(INJJ>t%`DfIj}6%zmO+=-L{b!P zLRKvZHBT=^`60YuZon~D$;8UDlb-5l8J=1erf$H(r~ryWFN)+yY@a;=CjeUGNmexR zN)@)xaHmyp$SJcl>9)buKst5_+XomJu34&QMyS zQR(N@C$@%EmfWB8dFN(@Z%xmRma@>QU}!{3=E`wrRCQ~W=Dwb}*CW8KxAJ;v@TAs3 zW}Pq5JPc)(C8Rths1LR}Bgcf6dPOX<#X08^QHkznM-S>6YF(siF;pf~!@)O{KR4q1_c`T9gxSEf`_;a-=bg6=8W zQ&t`BK^gsK-E0Jp{^gW&8F9k?L4<#}Y0icYT2r+Dvg!bnY;lNNCj_3=N=yd9cM9kY zLFg|R0X;NRMY%zD*DbAmFV`(V@IANtz4^_32CH*)XCc$A>P-v49$k@!o$8%Ug>3-- z$#Fpo9J>eUMKg>Cn+T0H!n0Hf#avZX4pp54cv}YcutP+CmKC~a745-zhZp`KNms;J zS3S49WEyS8gCRAY|B~6yDh*cehY52jOSA#MZmk2dzu`_XpBXx9jDf!H3~!`n zaGe=)1VkfIz?*$T3t>-Pwhrw447idZxrsi;ks;(NF>uVl12}zI(N~2Gxi)8yDv-TLgbZ;L&{ax&TBv;m@z6RcbakF^el{!&)<___n#_|XR%jedxzfXG!a2Eyi)4g zYAWkYK{bQzhm|=>4+*SLTG2<#7g-{oB48b05=?PeW;Jo3ebWlo5y5|cl?p8)~PVZqiT^A~w-V*st8kV%%Et1(}x(mE0br-#hyPspVehofF`{gjFXla1lrqXJqQKE9M)8Xe0ZO&s$}Q zBTPjH>N!UU%bRFqaX(O9KMoG$Zy|xt-kCDjz(E*VDaI={%q? zURR{qi>G^wNteX|?&ZfhK-93KZlPXmGMsPd1o?*f_ej~TkoQ#no}~&#{O=>RadgtR zvig@~IZMsm3)vOr`>TGKD&fbRoB*0xhK7|R?Jh-NzkmR}H6lJiAZTIM1#AXE1LOGx zm7j;4b(Lu6d6GwtnsCvImB8%KJD+8z?W{_bDEB$ulcKP*v;c z*Ymsd)aP+t$dAfC-XnbwDx3HXKrB{91~O}OBx)fsb{s-qXkY<@QK7p-q-aaX&F?GS z2};`CqoNJ$<0DuM2!NCbtIpJ9*1a8?PH#bnF#xf~AYOIc4dx1Bw@K=)9bRX;ehYs; z$_=Ro(1!iIM=kZDlHFB>Ef46#rUwLM%)(#oAG(gYp>0tc##V{#aBl!q``!iIe1GBn z+6^G^5)(nr z8h#bm1ZzI450T?!EL)>RWX8VwT1X`2f;dW!{b~S>#$Pa~D6#Hp!;85XzluH%v5325 z730-aW?rY1!EAt;j7d23qfbMEyRZqxP};uID8xmG@mGw~3#2T^B~~14K5?&dP&H@r zL|aXJsEcAAXEXfu2d-!otZTV=if~^EQD*!NkUFQaheV&b-?-zH6JfjKO)aYN=Do*5 zYZ-@m#)5U0c&sUqu_%-Editr5#%Ne&bs)DxOj2_}`f;I_ReEY9U&Cf3rb>A3LK(ZD zid0_-3RfsS*t&g!zw}C_9u(_ze-vc1L59CdBl(IS^yrvsksfvjXfm>(lcol%L3))Q z@ZT;aumO3Q#8R!-)U697NBM@11jQ>lWBPs#?M4_(w=V_73rsiZh8awEm>q1phn1Ks ze@D|zskeome3uilE8-dgG(EojlI(@Yhfm}Xh_AgueHV`SL##I@?VR+bEHH=sh21A_ zhs&pIN7YTLcmJiyf4lZ;`?pN0`8@QbzDpmT`$m0CTrTMiCq%dE&Cd_{-h`I~f8Kps zAuZt4z)}@T>w$9V@iLi=mh({yiCl}}d>JN)z;*G<6&mgl(CYhJHCAPl=PYK2D>*F zy;YK=xS@1JW7i=C)T04(2P#|fowalY=`Y`G8?eRMAKt|ddG9UF^0M5 zW=ZGZ5qb-z@}iS`4RKXvuPIfzUHT)rv<8a|b?bgB3n=ziCiX4m2~CdVBKHWxw2+Hz zLvqoAij9(0moKoo2$`dqS0?5-(?^RXfcsQB6hU2SAgq8wyeasuyFGcK+@An?8ZzVw zW8wwbZB@i=<<4fA7JKPkki6y>>qO3_bW>-uQ*>9g+g7M0U^`RV)YTrGu2Q=2K>fiI zY0dFs>+}xuOZE^efLK2K6&X@>+y10Oqejnnq^NjfXt9JpK4K_E=cl29 z(t2P;kl4AK_Jg9v{1(z)ESpyo_(Z`74D&J1A#J?l5&J^Ad1sm5;Po@s9v7wOs(=_T zkutjt`BaxT09G{-r>yzyKLlM(k`GZl5m+Tgvq=IN|VjtJ*Zu66@#Rw;qdfZqi15A@fr^vz?071F5!T`s>Lx5!TszI%UK|7dDU;rUCwrRcLh!TZZ9$UMfo z@Qzjw>tKS3&-pyWS^p4mMtx`AvwxVc?g?#8aj@jQ#YKDG0aCx{pU+36?ctAiz=f$k z05S(b&VPQgA(Sm`oP&M^eiHvBe&PcTb+j$!!Yx(j3iI5zcQLOn(QqfX5OElbSsQBUw7);5C92onieJyx`p{V!iwXk)+1v zA6vStRZo0hc>m5yz-pkby#9`iG5+qJ{x>6I@qeAK zSBFylj8{FU*0YbFd2FZ6zdt^2p?V;3F~kap`UQgf@}c33+6xP)hK)fmDo@mm=`47* z9S6rnwCSL&aqgZs959!lhEZZp`*>V8ifNmL;cqajMuaJ~t`;jLPB?X~Ylk_Z#Q;%} zV+sAJ=4505-DdnIR=@D_a`Gy#RxtSX+i-zInO@LVDOd*p>M-|X(qRrZ3S(>(=Oj>} z89d75&n?m^j>;SOXM=)vNoum|3YmzxjYx%^AU*V|5v@SjBYtESp^yz?eQ#>5pnCj} zJ_WCw23wGd2AA-iBve8Hq8`%B3K4@9q@a}sf$49IA^IPsX@QK)36mrzqOv?R_n9K@ zw3=^_m#j{gNR0;&+F~wlS(i8IQN8mIvIO)mkx|e)u*y+xDie}%mkZ*m)BQM^$R@-g z1FrP0{8A?EcxtxxxX&J;393ljwwG?2A2?y-1M0-tw$?5ssoEsbPi?sd2!s~TrwPLF zYo-5XYV7AU-c|Vb-v;>pVi^CwX(Rpt<9{Ic?@<9SrNu>F(gwij%?dC9^!Xo90o1-| z&_aPKo%+xyw64e&v<}F^-7sO0Cz-VOF@7**i@v&(Oy4Q8PbV+4&rKwmYyokM z48OZ|^%*mC_Q)RJ31D#b4o4Jzr{~BX4D#swW<31;qCil2qlim;e=9ymJAEXfv-|h3 z)>uqQ5~S+8IgiWW28Fqbq+@ukCLy+k7eGa1i5#G_tAUquw$FjFvQt6~kWa69KXvAj z-knF`5yWMEJvCbTX!K{L)VeNF?(+s?eNjtE5ivg^-#937-l()2nKr#cHShB&Pl^l8 zVYws26D^7nXPlm<_DYU{iDS>6Bq0@QsN%6n>XHVvP<^rDWscC!c+LFrK#)T@$%_0{ zob%f&oaq>1_Z8Ata@Y2K6n?GYg|l8SgUr(}hi4D!@KL~hjRv<}ZZ`tCD^ev=H&^0pP%6q2e+t=Ua`ag8xqWvNnIvCU|6ZA^L5v{DD)!mcQ@n6{=; z#Z)PrAz>*+h-|IV!&J*f@{xb!L7h3{?FEs*ifw5z2U9$&OkYseI68yb=V4xv*VK3- zVxGhtmedujX32y-kC{5ej-Wy#JvB~4oxTb{|1H825_B(A0#?CjUTc=PrGh6jAgK9h zoLAe`+NBdStZE@Y8UH^Rd*|R-|7Ke}wr$(CZQHhO+upHlCp)%n+fH_}S8%^%xqhu%20_1p=x#Dl9ia`c3iM+9Vh5?gyY8M9c$tJ5>}V_sidHN zoMl%rSgSK!7+Y8tQkYq|;Vh`4by2uMsUfnxkk2{S@a>V#d}fv}Yud*>paVi_~T zU!GoYwWbnG%92!Cte(zhZX-i9#KJ;b{$(aZs|{MerP#6||UUx$=y)4XOb zihyKn`_QhJ#~@_peJ*8yD4>I7wQyKkZG%#FTKZfb(@G+9x7-3@hG}+ZC&$7DwbaB$ zC)jLj7yituY&WpOWlG7Z4Tuxzdwo6k!3lgwhh7BYMyB? zO9Q5nvn77~g~c623b`Pe5efNzYD#2Sfmg>aMB5s?4NC|-0pIXy%%`J;+E{(irb!Szc8M8A@!}0zqJLoG4SJ5$~1*yRo0^Z`uObA+= zV?1sYNvzvWbP%AsMzoIo3Cwx~y%i8rHF(BgLS>tH5Ab|1wp$X_3o2_VB(pFxgQ5QQ zk@)Vy95$b%HVf4@ppX(wrv^Jwfrsu+9N_OUm}nD7Ch_7STj66EYsZR#`9k|Tf^@p& ziHwnO$p{TB#R(Q{Os>Un~0!r$JO zLZ&F%SP|%$TuG)mFeOhKr1?S!aa0jTV$2XIeZb_fgO&n{8HTe9s`L&(tKoy?OaS^$ zLHNrgYgq920EI~M>LyU7gK70$7*`nFKD^d>MoEAhsBU0%@*RW@%T(J z?+wVbz=mcN%4#7qlCpl_^Ay7VB%?+uW1WSNnQOj^tALyqTpV zkEN2C;qO_W)MYl^Ow5I;t3;z#iG82F(qe}#QeE;AjA=wM==dB(Gu+ez*5|RVxO4}l zt`o?*B;);-0`vR(#+Q^L4WH_9wklh-S-L-_zd%Q0LZ%|H5=>Z)-x#Z+m%p&6$2ScV zEBneIGo)r0oT)xjze*Q~AIqhB%lOM5Id}^eKwS!?b_;B&TouZsemyL&y`)#FX}ZKp zp)ZnB*^)1P@2bCoe+Z|#KhTBNrT)UN@WIuudw})fwHl)re1|b~E1F=xpH?7L77p>5 zei$aD@KO0<+zo1<&7OuZatNsPq24Whu%0jD_ z$ZZy6MzayYgTJulNEy8D$F%JDYgx|d6{6kpDg#s170<15bM#4tzvrDU$6bvu-hH@6 zgcjq&3aR3k(23$FaUA|iuoy*bO{2F6W0<+ZdsYvXjc?d@ZT8kM!GD}r@qr;TF@0Hb z2Dz-A!HZ$-qJ?F%w6_`t`8xk$f$MNBfjqwvJiVdD+pf7NVFGh?O=qp2vh%UcYvc{rFldib~rkIlo`seU%pO_6hmBWGMcUhsBSWiQYYPMX<-Cjp49@7U==iS57bG zw3T9Nbm`)m9<<4e$U74`t~zRo0JSfi}=GdQXGLLPyW zlT^I}y=t$j{Vx!wN^z8X4l0|@RNrC#)G>bK)7IT7Qop>YdS^NnI3gfP>vtp)pXkr2WSVcAAv8uN>@ z`6)kICvNYU$DA8pnkl4sQopDC6<_M8zGJ^@ANXJL(yd#n1XFj9pH;rld*gwY8om_I zdB55w@FUQ_2k}d%HtQsmUx_7Mzftky&o2X2yDQrgGcehmrDDDtUJj5``AX$gzEbMc zUj2Qzp)Lo>y-O*@HJ|g9$GR2-jgjKfB68J6OlIg;4F2@2?FlW zqj|lO7A2Ts-Kd!SO|r9XLbPt_B~pBpF40xcr0h=a&$bg(cwjp>v%d~Uk-7GUWom?1 z92p+C0~)Og*-N~daT#gQdG{&dPRZso(#{jGeDb1G`N)^nFSB`{2-UQ&!fkPyK`m03 z_Di94`{-(%3nE4}7;4MZ)Pmawf#{}lyTSs5f(r;r1Dp4<;27K=F}Oga^VsUs3*NIn zOsYstpqpRF&rq^9>m50LRORj>=;{CV2&#C$-{M5{oY9biBSoQyXvugVcwyT-19S;pf!`GSNqb4**TI%Y z*zyV)XN3Fdp3RNNr9FU+cV*tt?4L8>D@kJp^rkf_rJ~DPYL}oJngd1^l!4ITQN`0RTT^iq4xMg|S6;d}lznE$Ip^8pW-CHu zP*^!U>Lcd3*shqa)pswq;y<|ISM1g1RG#`|MSPNAsw*XH1IAD(e(Kgqp6aDHgv>fI z!P67$z{#()Pdo3;4dUoy*Xor(O?+YTRPe=g*FfRj*9q9!8p%1l>g3e^rQ_nm{(@4t z?^nMDC2J8@my5q0QyCljCSp_@)No+6bZ*y)lSdrkLFcR6YOHu*vZ-q(C);5$MmM_z z1WT>Gc8g%`Rt~6*!}JhWi0=Rc_z5c8GR9YXW+cdoK~Ea(@wyXf|89HagNuFAO-V7k zUb|9zaCCWH3^Fz(m7$8K$|0ZOP!SNpgP!ql<)!z8w$Z$?9gq2f<~koe3|zD=imLfD z>IV5?SkRZ;7JlOG%z%Tlze$GXr0A}ResyF63ZGZVDLv2k4HWtoqoCaq+Z&GaVKuLA z>@zhNjYYc=sexH?;DTe4&2vnQE}C@UFo&|qcLddvH0FwswdRUc(p*X&IT^Zu>xLpG zn(@C%3ig(l2ZPm#Fc){+0b+%O7nt4zbOt+3@GQVm|1t70=-U(>yo3VY2`FnXFHUyi zwiqf(akt0kEE5_Pa-a*VCS}Pi6?`~P%bvX6UT~r-tUAY%I4XF3^nC+tf3alyL{M`w zv?aVQ#usdwpZmkrfv19O39}tQPQM+oY**a{X?@3Qe>r$+G!>r#?Id&U&m^HU(f= zjVpSi9M||1FyNQA&PO`*94&(qTTMQv3-z`bpCXs-3bX}#Ovqec<>omYhB*VrwxqjY zF3#OXFsj`h#G?F}UAilxTQ|78-edHc-Uc-LHaH*Y(K%R#dVw>_gz}kRD4s#+U&Pq= zps)kMf_t9`GHR7CO4zI8WVj0%qiSqy50N{e_5o#GrvNhMpJf5_sCPrEa%a@ltFnss ziaWh26vEW4fQp}qa4oP(l4xIMpA)~VHD9!lP%;Tm`(HD$jYMM-5Ag>S(gC35J35$%?^gk(r|`4Ewi-W z;f&;B*fO=kC@N=r<-#nGW|yXE;`zb0Y3TJOAkw1a$SQgoTawHZTck+V%T=spmP`^BHihc(jc+S1ObX%6AYQ6LVVc+BfM*P{2s0T2z zVIs*5{ql%#CKAzv0?@S+%||z;`dpfj0Y(VtA51n$j%sG5I%A|h98VU}PkVZFrk1*G zaw75v3(N50lanvr&ND4=7Db;HS4fpi)2vTME7aD2-8N5+kcOXmYCrLE?*5&dWhvB` zbD5)ADuIwwpS*Ms;1qyns(8&tZ*)0*&_lNa`_(phwqkL}h#WdX_ zyKg%+7vP>*&Fus9E4SqIN*Ms`QLB(YOnJ|md%U|X`r#tVN$#q6nEH1|blQ?9e(3|3 z`i#;GUl~v?I6&I6%YvkvmR?*l%&z)Pv8irzVQsWrZSr%aoYuPJa#EjK|4NmiuswK= zlKP2v&;yXv3>LQ$P){aYWrb)5GICwbj;ygw>*amKP;Z{xb^cF}O@IeQ^hB-OjEK{l z>#PNyLuVkeDroL9SK2*ChHmJJSkv@YRn7)E49fy!3tqhq`HtHs_(DK|2Lyv(%9L&f zSy+H}Uk{nE2^5h7zN7;{tP3)$1GK9Xcv^L48Sodg0}ZST@}x607yJo2O*XCfs7*wT@d?G^Q6QQRb!kVn?}iZLUVoyh8M4A^ElaHD*Nn2= zkfCS=(Bg9-Mck6K{ z%ZM59Rs4(j1tSG1B#wS=$kQfXSvw6V>A(IC@>F;5RrCos`N{>Oyg|o*qR2EJ>5Gpe ze~a4CB{mmDXC7C>uS@VL&t%X#&4k<`nDx;Zjmo%?A4fV3KOhBr;VuO!cvM8s2;pG5 zcAs!j?nshFQhNA`G3HMS z?8bfRyy1LwSYktu+I7Hurb-AIU9r|rl5nMd!S&!()6xYNJ1EqJd9BkjgDH@F*! zzjtj4ezywvlkV7X@dG^oOB}T76eK=y!YZB#53LhYsZuP&HdmVL>6kH8&xwa zxv8;t-AE>D5K<{`-({E0O4%fGiLVI8#GfZ0aXR6SfYiPUJKnujMoTI5El<1ZO9w|u zS3lJFx<7XUoUD(@)$pDcs3taMb*(v2yj#G)=Mz-1M1q@Tf4o{s9}Uj9Yo?8refJwV zJ;b+7kf0M}fluzHHHS!Ph8MGJxJNks7C$58^EmlaJcp`5nx+O7?J)4}1!Y>-GHf9o zk}oTyPa>+YC$)(Qm8|MhEWbj?XEq}R=0NFH@F3ymW>&KS!e&k5*05>V@O*~my_Th; zlP05~S5@q+XG>0EuSH!~gZe_@5Dbj}oNIiPJpEOip+3l!gyze@%qOkmjmx=?FWJLF zj?b}f8Vet*yYd16KmM43rVfZo?rz3u|L6Foi*GQe4+{REUv9*}d?%a{%=8|i;I!aT z7Wxm}QJC`?cEt9+$@kSkB!@`TKZz1|yrA1^*7geq zD5Kx-zf|pvWA+8s$egLrb=kY385v2WCGL{y4I15NCz5NMnyXP_^@rsP#LN$%`2+AL zJaUyV<5;B^7f+pLzTN50Z~6KC0WI<|#bMfv+JiP3RTN^2!a7*oi+@v3w*sm5#|7zz zosF*{&;fHBXn2@uguQ1IDsh(oJzH#i4%pk;Qh^T zfQLyOW;E*NqU!Fki*f-T4j(?C$lY2CT{e!uW}8E(evb3!S%>v^NtNy@BTYAD;DkVo zn9ehVGaO7s?PQBP{p%b#orGi6Y&~<;D%XLWdUi}`Nu-(U$wBBTt*|N4##sm2JSuWc)TRoYg57cM*VDGj~ka<=&JF zo8=4>Z8F`wA?AUHtoi$_hHoK!3v?l*P0$g^yipOWlcex4?N2?Ewb1U=lu}0`QICA4 zef61j-^1p}hkA*0_(esa!p%dX6%-1e-eMfQsIp6wRgtE=6=hDe`&jel{y=6x5;78s z?5^{J|t!#x1aS8<3C`v%E%u{*wZwSXr$0Owl5_ zmXh>D>C_SjOCL^CyGZpBpM5`eymt{*rf~9`%F&&o7*S!H%3X)7~QFgn^J>6 zD+yV}u{HN-x9*_$R;a+k?4k*1f)rE~K|QvcC3dlr>!nftB?gE-cfcPMj&9mRl>|Lg zQyCe|&SuZopU0>IfRmcV3^_mhueN5oQ=J+H4%UsSIum4r4!`^DJqZr?1j3BU)Ttzg z6LwM)W&UEMIe*H2T6|{rQ;x9qGbp7ca#-!Egm4|ECNTMN);`>2Q&%|BpOdIJ4l|fp zk!qEhl;n(Y7~R1YNt7FnY10bQZXRna2X`E_D1f*}v1bW^lJorDD0_p2Rkr32n}hY! zCDB(t$)4YOd)97R60gfg3|wrlsVs#4=poh4JS7Ykg$H)vE#B|YFrxU-$Ae^~62e;! zK9mwxK?dV4(|0_sv(zY&mzkf{x@!T8@}Z6Bf)#sfGy#XyRS1{$Bl(6&+db=>uy-@y z$Eq~9fYX$06>PSKAs#|7RqJ3GFb;@(^e`jpo-14%^{|%}&|6h{CD(w@8(bu-m=dVl zoWmYtxTjwKlI!^nwJ}^+ql`&fE#pcj*3I|_Z>#y##e@AvnlSN4po#4N#}WT)V5oNP zkG+h_Yb=fB$)i`e2Fd28kS$;$*_sI;o0Xoj#uVAtsB6CjX&|;Bk}HzQ*hJ!HDQ&qZ z^qf{}c`l^h5sg-i(pEg#_9aW(yTi?#WH=48?2Hfl_X+(SfW)_c48bG5Bf+MDNp>Y#Mpil%{IzCXD&azAq4&1U10=$#ETJzev$)C*S;Pr9papU3OabRQk_toRZ!Ge(4-=Ki8Db?eSBq~ZT#ufL6SKaXZ+9rA~ zQwyTQTI7*NXOhn?^$QOU>Y6PyCFP|pg;wi8VZ5Z$)7+(I_9cy--(;T#c9SO;Hk~|_ z0tEQ)?geu8C(E$>e1wy%f@o;Ar2e#3HZP$I#+9ar9bDa(RUOA+y!oB;NEBQ`VMb@_ zLFj{syU4mN%9GF;zCwNbx@^)jkv$|vFtbtbi7_odG)9s=q(-PtOnIVcwy(FxnEZm&O^y`vwRfhB z7Urcums9SQS6(swAgl?S|WDGUTFQu51yG$8069U zviuZ=@J&7tQ8DZG<(a->RzV+sUrmH$WG+QvZmUJhT*IoR3#3{ugW%XG0s?_ycS6V6 zS)019<_Rl@DN~8K4#w3g_lvRm4mK3&jmI$mwROr0>D`mX+228Dw4r;mvx7df zy~$zP8NjVX?xkGFaV>|BLuXMQ+BN+MMrIB4S6X)p&5l$;6=S8oI9qi&1iQbs?TroDMfCmIeJ}pbVVtVqHhS(zutEy6#UjTk29-+3@W0`KfehW`@np zhhu#)O&g%r)hTj4b$CY41NYp_)7!bYyG;v(rts z^}YDJt2W88H^H;e$LSm3dh=~yi@)mzJtEfW8=4avbeOE&;Oc>-6OHO+MW`XBZ4rO6 zS;nAi**w3Yso4&Ty+8f$uvT?Z)eaLe$KW1I~9YM2zeTIT}C%_G6FPH-s5Wi3r`=I&juGTfl zZ;4qFZV|6V0c&>t!Y>mvGx#1WWL0N5evV=u28K9**dv`}U3tJ$W?>3InXiwyc)SA% zcnH}(zb0@&wmE>J07n#DOs7~lw>5qUY0(JDQszC~KAAM}Bmd-2tGIzUpO@|yGBrJyXGJk3d+7 zJBN0$?Se(rEb0-z2m%CBd;~_4aH04%9UnSc4KP!FDAM5F_EFujJZ!KDR-fn181GX` z8A?8BUYV}D9bCE0eV~M>9SPag%iVCLWOYQJDzC4~B~Ct0{H7x|kOmVcTQ;esvyHJC zi$H0R73Z8+Z!9^3|2tNut#&MVKbm`8?65s)UM8rg6uE(|e^DYqvoc15-f;u8c=>3;Viz*T# zN%!T+Hex0>>_gUKs%+lgY9jo6CnxL6qnQ>C*RseLWRpipqI;AQE7;LUwL`zM%b`Vu z%Sa-+?a#+=)HaD|k2%_(b;pHRF96(c;QyPl6XHL8IqGQKC$M8R=US-c8;hUe?LKo&l!{V)8d&55sUXEu z5uITcO~`ipddh+Nr{7ibp^Wd{bU)^3##<5`lkuqfckxEU*9{pgNpTB2=ku1c-|3dK z|LIQF=ld@I7swq^4|G1VA}BK85&>2p#*P95W`I1FF(8G9vfNJ6MoN$+C^M89u!X=< zJSS%l?Qj>$J%9?0#0&S6#*h*(-9Z$}q*G#hP?cX7cAvM0eiVFhJJ~$`iZM!N5NhDb zi<1u_m#?jzpIaOe7h|Kiap#mHA`L|)ATnPJ7du{^ybuNx@1jA+V1l8ux#{LJ#teM(6=%gZcMq24J$2p z`wcC!qRssmwUv4H6Psw{(YdDNOv$!sq&O1SvIS}fCKZa+`T=Ayt@uZjQqEC{@Uj+| z!;i3W+p~=@fqEEhW@gT^JtCR<`m`i|Htg<TSJ&v`p;55ed zt@a|)70mq;#RP@=%76*iz>fAr7FKd|X8*@?9sWOFf$gbH$XFG zcUNu#=_+ovUd>FW*twO`+NSo*bcea=nbQ_gu^C7iR*dZtYbMkXL5mB@4a3@0wnwH! z(fZKLy+yfQRd%}-!aPC z4GB%OvPHXl(^H(BwVr6u6s=I;`SHQ1um7GPCdP-BjO%OQUH!_UKbEGvHCY}{OL`8FU$GZ;Y$SlS$-0VjK%lCP?U0shcadt4x7lN4%V}wBrLEbiEcK-OHl+pcBNSqN#mftpRj2A4Q z+av@-<#t_Dj_FN^O2~wq(ij1O*+=RVl+6gNV^~CI1UED- zn^zN@UOq8?q58b^4RA>lV}x;jA2OE=SqMYV9P#RsUlI+pp!y*jpwHgp-w3i$V)%?L z>irn1pnRc|P@r|Z0pCeMZ*k$}$`1GVGCT&QtJ`V%Mq!TXoge?8Fjn$bz}NqDn*2ZQ z$p3@F_^(}IVS76>OLNzs`O5!pF=LZ$<&gyuM$HQzHx8ww^FVxnP%Yv2i=m*1ASF~~ zP=!H}b`xl`k0pL5byku2QOS~!_1po!6vQyQL#LQ#rIRr?G5^W?yuNvw-PP{}%m35i$i+I?DJ%RGRcqekT#X~CxOjkV1UQrd&m_bbJ+gsSGbPwKS{F& zU-`QNw!*yq#Co#{)2JvP-6>lY$J$2u+e=r0&kEc#j#jh@4Tp;l*s<28wU%r= zezVPG^r*a?&Fn_(M|A7^xTPD998E-)-A4agNwT?=>FbrHz8w~w?hWBeHVYM()|buJ zvGv4j<%!U_Rh^ZKi~2(h1vk-?o9;`*Zc}m5#o@a1ncp)}rO2SDD9y!nT$_Eb%h`>% zDmssJ8Dl=gDn<-7Ug$~nTaRzd?CJh;?}nCco$7Pz<#J8;YL40#VFbAG|4nA$co;l^byBOT2Ki@gAO!{xU7-TY|rujdYTaWV(Rr{Jwu?(_TA zDR1|~ExJBfJ?MAReMF47u!oEw>JHVREmROknZUs2>yaboEyVs$Pg1f6vs06gCQp$b z?##4PWI#BxjCAVl>46V_dm4?uw=Y@h#}ER4|ACU{lddiweg`vq>gmB25`XuhNai1- zjt{?&%;TRFE+2Y_Gn;p^&&|bU44M=`9!Mc%NbHv|2E4!2+dUL z>6be$Kh|Duz}+)(R7WXsh!m`+#t^Its($x`pqDaN-^E z?*a=0Ck^rZBLQV~jY-SBliN&7%-y3s@FB;X)z(t&D=~@U0vT%xfcu`Lix=W#WVE{{ z2=C~L$>`~@JCIg8RAyk= zYG`(@w4H95n0@Fqv16~nlDU!+QZw&#w@K)hv!V>zA!ZOL$1Iykd&Su3rEln@(gxO| zxWc++T-rQEIL+j7i`TeatMfp4z7Ir31(TE4+_Ds@M|-+cwQg(z>s=S}gsSz{X*Wm+ ziKJWgOd`5^o|5a#i%?Gvw~8e?Rpi7C>nQ5dvPHVTO$PI^mnJ*7?gd3RD{|c_a>WrXT#Es3d}(k z$wpmA#$Q^zFclx{-GUL_M$i0&mRQMd4J#xq-5es)yD{kYCP1s!An(~K5JDRkv6DUSKgo^s@lVM5|V4mWjNZp zsuw^##l%rbRDKglQyj?YT!nk$lNUzh%kH705HWhiMuv(5a<~yoRDM&oCqm+1#S~|8 zA$g2Xr=}p_FX%Eaq{tUO9i*Q1i!>$+1JYZCL}flWRvF0y1=#D#y-JQTwx6uP-(bC} z_uP7)c;Xd`C6k#JVW?#Id7-|`uW+hN0>OM=C2Ta^4?G zr;EvxJ{%l|8D-heRYRM%f*LBC)krHZJ@%&CL0)FADWh14&7KV<9km6gE=o9(7keg~^rIQtthK^_8%Jk&aZLY_bc6SbY>IcwDK9{sV*t1GfKwf8aCo8t za)yALEi^-WXb!k6n>W-62Z^n8hO|eRYr&uZiW5d_URi??nl*aGu?ioQ+9RF9u8kwD z6UZ6HVd(G%l9>y7E)uyn?gAJMKeki0@tG*jdcE-}K?8(D-&n=Ld1i=A1AI<1z>u5p=B z<1}|q3@2jNxW-}Q4z~s|j&^Qc;nXIdS3K8caP_07#ig} z#KAD&ue2jXc&K#Q`Hy#x+LeT4HHUCzi1e?*3w{tK+5Tij(#2l2%p#YGI-b~{5{aS8 z!jABC*n6y~W|h;P!kn(a4$Ri2G118!?0WHDNn((QDJP^I{{wPf<^efQWW?zS>VS?X zfIUgCS{7oV$|7z2hJBt+pp1CPx4L{B_yC3oWdE)d)20WG6m5qknl}8@;kjPJE@!xP zV(Nkv^-Vz>DuwBXmKT(z>57*D<$u=Blt)IS-RK0j89omD{5Ya*ULWkoO)qeM_*)jF zIn87l{kXPp=}4ufM1h7t(lAL?-kEq>_DE-in8-!@+>E1+gCV9Fq)5V3SY?**;AKq0 zIpQ(1u*3MVh#tHRu5E5=B{W-QOI34plm`#uH(mk*;9&Re%?|v-=fvb;?qvVL@gc|l z8^L?2_0ZrVFS-stRY(E>UiQeG_sMrw5UiO znGFLOP-GO{JtBM@!)Q37k3G_p&JhdwPwtJS6@R4_($Ut^b!8HP{52-tkue8MG=Zwr z7u6WaFranJq4oNadY)>_6d~?pKVxg$2Uz`zZPnZVHOh-;M|H7qbV0OF8}z;ZPoI+| z(`e}bn6u*kJpRLC>OZ}gX#eHCMEk#d8y$XzSU;QZ|An$pQ%uZC$=Ki!h@&m8$5(xCtGaY3X1FsU?l5w^Fr{Q-?+EbUBxx+b?D z80o*@qg0juG;aZhj=tO=YHjfo=1+-NqLME~Kw7Y1A*?}M7#cOyT(vd$1tVPKKd@U! z&oV!RzZcK6gPWj`*8FIAy2I&x``h_sXPe*O{|ih(Y+V3|o68MWq~2Iy^iQ8RqK76f zC$1+hXqd^jsz`U{+EFo^VQNrLZt#R`qE*>2-Ip&(@6FmtAngx@+YnG}b5B9Y)^wg#oc z24KlT2s!H_4ZR^1_nDX#UH4(UTgl603&Q3g{G4!?6Sl9Om=Sy|8CjWO>d@e9?Q%s- z-OS3*W_H7*LW|Ne{b+^#LqQ}UKDmiZDma@no2!ydO^jcm>+z379K%=Ifs{20mT|xh zP$e7P=?N(tW4PMHJOQ`a8?n}>^&@<`1Rgo`aRevPp^1n7ibeS6sc8^GPe>c&{Kc+R z^2_F~K=HVI45Pf|<3)^;I{?H}vU7-QK3L1nHpcn3!1_)<$V;e0d_b8^d1T==rVpky zZTn~UvKrjdr11k}UO@o>aR2wn{jX5`KQQM1J1A?^wAFvi&A#NA#`_qKksu`sQ0tdM ziif17TO<{wDq_Q;OM}+1xMji^5X=syK=$QdZnS#dwe$;JYC7JozV8KpwfV}?As|^! zFlln0UitprIpuzLd$`<{_XoUV>rrHgc{cUQH-Px#(_Ul%=#ENrfJe@MRP_$E@FLMa zI`(J)Imw$o427@Oc^3(U&vz}<3Lfmy7diVpJJJ@gA>e;q-&gj zcGcBC_luF%_;**EB?o--G?AkaruJ%-b*8aX$4E+-?V@RWMnjHJ;hx27Vd7l0nUUY( z6OQb&8g8cvN3LZ%^xvIav*X|Epqm@yrTZk9U{GSZXAUJt8Lh(%7?Eaf&AzmXOVvU| zmz<@l1oMe#^POR38KT6q3@c`{%eYNu4ccurv`q?b5DzLxENjSfYOJHAI$MbSNgB*D zJsP>i*BgrFlIn?x&DH9x~UbPBtMFj{_vJ#CaAF>1$oE&k`EF&L@HCa@mN>Q7~!RU>7 zW%fv84aCKSgBacmuvg}r@)YKqO$U{D5|!`vG-Gp%An}raz2gESWm0Exhux4C)zE}} z_@kn z3t}bvm?L+@@az@<*jG>(Xopq&c*;^mttlJ!mv;5k6o%Ac<_`o`4G3qzzo(GO{!&F8 zW+~bF?S;7gO1dQ@>gwZ?iIHjE#^@;Ix!Z`R6{RYLlGB&v4A)ha(2hc`RGV-8`LcvSf+Y@lhT%(Z7$tWEF;cZs2{B|9k#&C}sPyr; zd-g~${TqY7E$9X+h4_(yMxQ%q;tm(h(lKzK)2FQ%k#b2}aMy+a=LHYgk?1|1VQ=&e z9)olOA5H}UD{%nu+!3^HsrBoX^D9Iy0pw!xNGXB6bPSpKDAaun{!fT~Z~`xp&Ii~k zdac?&*lkM+k_&+4oc6=KJ6RwIkB|st@DiQ!4`sI;@40>%zAG^!oG2@ z@eBM$2PJ@F&_3_}oc8A*7mp-0bWng^he9UYX#Ph*JL+<>y+moP^xvQF!MD_)h@b}c2GVX8Ez`x!kjAIV>y9h;2EgwMhDc~tn<2~`lf9j8-Q~yL zM=!Ahm|3JL3?@Tt(OuDDfljlbbN@nIgn#k+7VC+Ko;@iKi>~ovA)(M6rz5KP(yiH| z#iwJqOB7VmFZ#6qI~93C`&qTxT(*Q@om-Xb%ntm_?E;|58Ipd1F!r>^vEjy}*M^E(WslbfLE z<+71#sY~m$gZvoRX@=^FY}X?5qoU|Vg8(o`Om5RM6I(baU^6HmB<+n9rBl@N$CmP41^s?s1ey}wu3r3 z4~1dkyi%kA#*pLQy0phlXa-u(oK2Dwzhuex$YZv=*t*Tg5=n~H=}fJA!p2L78y3D2 zimkqC1gTU(0q||k9QM#><$b-Ilw#Ut2>JF=T^qN34^qcBEd={! zB)rxUbM2IwvMo?S;Id^aglw}-t9et}@TP;!QlFoqqcs(-HfNt9VqGFJ4*Ko*Kk#*B zGpJ>tA9(=t|4#M!kBaf%{$Kfj3-uf|ZFgiU`Bo>%k_OuAp~vnE^_Tg8*% z*?)4JdzyMTzvNDy{r$c``zBw=Vr)6c4}CBIv#mw()3h7`?V-;LF?J&N5a>kjpy;9n zQyXvuu`n?+W84QV=(i`JEJY=}Ak+u4>!Lyt2P!$nBl}T=^|pG*z@)_l!)OKB{tIV&&E@hj=OIhSBHgPV~X=R3NrTMh?VzDm?1yW^IJ&zzAn2{8rE~MRX5EE)a(-T&oE)1J4pGXBYi+nexX-?5! z{EZ4Ju=Y8MQ87=uNc2t^7@X)?85KeSoc`?BmCD;Uv_cwQaLyc}vvnJKHV zuK)H_d)xhGKB!_pRXv{$XgfZ_(8G%N3o$ZI#_ zixQj~so0*m^iuA!bT>&8R@>b%#B~zbIlwt4Ba0v&>B(`*Z;~?6!>-aQ zal+Qt4^dCcjZZMd4b4Khg~(GP#8$3BeB8j!-6l?*##)H?J$PeUy)cA_I26#0aggao zaM5PweS_Sb@{OZ@Uw*(!DNV)KTQU+BTRi?AUAv0Vowth`7mr9)ZVC+TI?@; zWGL&zydnsuE3+D7#U~P%PrxpD3nTc9#mm621iX*?ZMS_Q#n9SzOJ~Hg@`rX{d?qJ; zt}`76!H)MX#=VKifJZP$3<8@}0-llthFpq3FV;(UP$-k63MkHHq~J&}d?C<+c~*Zk z<#G&>AD7EoiAVO38TO2TOBKN>6N|JS*{+`}V-)T0j(bAzGlEUWEvWLrMOIItYexh) z?he>SJk*#bywgDF6+*&%>n%0`-3tOY72+n&Q1NJ`A-bX*2tJV(@;%b6&RxMcUd7+# z@UzOmc9DolSHc-D$5(GouinaE%&uOVMyD&CTdKaEB{Qap4_wU7_=23CULKQ;jmZuV;+Y$(`#Gh0@}s7-!qk-^&#IG>7B{yft?UoA)H5 z|B0u3Tu0TF{AB0jpT|E&RsYB$3WiQU^5p*|f)^Si_#^j+Ao^|5(gNjn+!0|NtXDt* z5fwxpajl@e0FrdEuj2s#Pg>gUvJdko9RBwEe_4@?aEM?SiA2nvm^tsLML{-AvBWM7 z_bm7%tu*MaJkUWd#?GWVrqaQ0>B%Azkxj+Yidvc$XdG1{@$U~uF|1oovneldx`h;9 zB1>H;;n1_5(h`2ECl?bu-sSY@d!QTa`3DrNj_F@vUIdW5{R7$|K{fN11_l7={h7@D z4}I;wCCq>QR6(;JbVbb4$=OBO)#zVu|0iK~SnW~{SrOq&j*_>YRzU&bHUhPPwiy($ zK0qin8U;#F@@}_P_flw`bW_v^G;ct?Pb65%=%egDBgS#YF3?E36$9xzdvYqjAZoK#hcjctJu~MF^S*$q3`o2;!L|jPnM1x*Q~qF%BH(5UDFYglsJwO zEdEuB7NihnTXK6$)F~``nmSQNFP7x7hE{WuOjTAhEjGw#XxvL@S;aZYuyu9)!yZ~X zo35D6Cwb8`shRXCCR;xlR`n`cs4aie!SSM`0)x3ykwM*k zK~w^4x2u#=jEEi`3Q9AU!wE)Zpn#)0!*~)(T^SEjIJveav(d1$RaSMC0|}<)?}nSG zRC2xEBN_YAsuKyl_3yDt%W^F`J-TyeGrcfboC_0Ta=KcW_?~RLb>xbqIVI6`%iWz; zM8Kq9QzwO8w!TntqcB;gNuV$gd+N|(4?6A9GEzYs z5f4(*N5}&ObeYA~I28r;?pKUj4N6}iloE=ok%1|X()Ahdwir?xf6QJfY7owe>pPj)Me*}c^%W-pP6`dnX1&6 z`b#*_P0PeM+1FR)t)Rnr22f!@UFBW!TxgjV)u0%_C~gIbb_D3aPhZ~Wmex0)Lj`VoZKjoW)dUoKY6*| z0|V)|XyjiKgZ}s5(SN?te*muif87vD_(wYOiOjOKNI4L*aK||2$~;s25HS#iY6r=)WW8a^dkd0Y|pPc1-9jmy&wqoCbL84`C94At6$lm_o!8m*did^?o$m?ozIp{RmZ*M%YMX_i$KYkz_Q)QK?Fdm)REqf*f=@>C-SnW{Lb;yYfk&2nAC~b}&B@@^fY7g;n(FVh_hy zW}ifIO9T7nSBHBQP5%-&GF8@A-!%wJAjDn{gAg=lV6IJv!|-QEXT+O>3yoZNCSD3V zG$B?5Xl20xQT?c%cCh?mParFHBsMGB=_5hl#!$W@JHM-vKkiwYqr8kZJ06n%w|-bS zE?p&12hR2B+YB$0GQd;40fJd6#37-qd1}xc1mNCeC%PDxb zlK=X|WE*qn2fROb4{oXtJZSyjOFleI3i8RBZ?2u?EEL1W-~L%7<`H6Vp0;cz5vv`7jlTXf-7XGwp}3|Xl6tNaII3GC z9y1w*@jFLl2iFA!<5AQ~e@S|uK4WL9<$R^??V^aM?Bgy=#|wl$D2P$o;06>{f)P+X z91};NrzVV+)b}k2#rYLF0X0-A+eRul=opDju)g0+vd79B%i!Y}*&a^L$_|C&jQN^j z9q#4<(4)3qNst^+ZYpyVF2hP;DN|OMxM9w(+)%kFQRcYVI zO-frej9x6a%-D%Xuwedcw9#3VSVkOjNF!BYRoY1KD3wFJ%?ML*3QwcarMK)@v`o%s z$w=NLrO>og`nRJpZZ(%~*hNJU#Y~k;_Ci3~gc=4UQO!Ydje^?=W^DgCKyO;Zz4LgQ zKtm($MdY;UZ((U_g5*pMY+dYGyyT1ERkaj`U#S-2yyJ47wMonCpV+2rI8zPNHDfo& zc59dFz*2#^A-R?P6Np}jhDLi4&vP%$NW#8J>=CLj1mlf$XzmQezH*F1jNOiPgXl2j zzD07AKLT*h$CA*OsOba2etPLU%|p?=XhplXo?vOu@q0{QBo++)@6U?YKv_)GFK(^Y zm&uFBbrQyzJm;c49O00PIt;|{&ei%VSS%Y3m3#~L#(3%Gso^a4#9AaB$w@vnAvdr6 z%!2#)YS0HFt%o)q6~BelT;?%oUjX%9qQCn#-~+TM(a^s%Y>&aBkL(UY{+?a9@&Q+a;t%c_6u^6_r@>MEAN9ir5q=Yo|R8z4lKYd1sv^LyTozFn$KqaJ>? zoH&+`AX>E03Gv=71+NZK2>!-NasKeCfMp;@5rZ z*m<}q2!$AgKUwWRXTVHs!E>`FcMT|fzJo30W551|6RoE#Q0WPD$fdA>IRD-C=ae&$=Fuzc6q1CNF>b3z_c<9!;))OViz@ zP58XOt`WOQS)r@tD0IiEIo4Umc(5f%J1p{y4F(1&3AzeAP%V)e#}>2%8W9~x^l}S4 zUOc9^;@m{eUDGL={35TN0+kQbN$X~)P>~L?3FD>s;=PIq9f{Xsl)b7D@8JW{!WVi=s?aqGVKrSJB zO-V&R>_|3@u=MEV1AF%!V*;mZS=ZK9u5OVbETOE$9JhOs!YRxgwRS9XMQ0TArkAi< zu1EC{6!O{djvwxWk_cF`2JgB zE{oo?Cyjy5@Et}<6+>vsYWY3T7S-EcO?8lrm&3!318GR}f~VZMy+(GQ#X9yLEXnnX z7)UaEJSIHQtj5?O(ZJQ{0W{^JrD=EqH_h`gxh^HS!~)?S)s<7ox3eeb7lS!XiKNiWDj5!S1ZVr8m*Vm(LX=PFO>N%y7l+73j-eS1>v0g}5&G zp?qu*PR0C>)@9!mP#acrxNj`*gh}21yrvqyhpQQK)U6|hk1wt3`@h^0-$GQCE z^f#SJiU zb@27$QZ^SVuNSI7qoRcwiH6H(ax|Xx!@g__4i%NN5wu0;mM`CSTZjJw96htSu%C7? z#pPQ9o4xEOJ#DT#KRu9mzu!GH0jb{vhP$nkD}v`n1`tnnNls#^_AN-c~PD;MVeGMBhLT0Ce2O2nwYOlg39xtI24v>pzQ zanl2Vr$77%weA<>>iVZQ&*K9_hfmv=tXiu#PVzNA;M@2}l&vaQsh84GX_+hrIfZC= z0Se*ilv-%zoXRHyvAQW9nOI2C$%DlFH1%zP-4r8bEfHjB3;8{WH`gOYt zg+fX)HIleuMKewYtjg+cSVRUIxAD9xCn+MT zs`DA7)Wx;B`ycL8Q&dR8+8mfhK;a^Rw9 zh9tC~qa>%5T{^8THrj^VEl5Do4j4h@nkrBG6+k8CDD~KB=57m@BL-)vXGkKIuVO9v z7t_L5rpY^0y=uu5iNw0v&Ca-zWk>v;fLJ=+SaV&V#C-o^}8 zp&Xp$v?~ccnfR=&5Df)32^d6QJLg*iuF#s|0M4zJF@Hza1p`q|f}~K)q;HC*I1_9t zQ&1jr9-kdUi8)DGxiwdqU|rPxYWDQPWY&SI&Rxkhxobp~C=Y*`d?HD4JW?WjU7dBPeuIE`ABLq95b#lfKS52IB^6KoHmm60$R}TESplQt59#mboJj+Na!P)V{ic@$yQ-&Z za^JU0T+n0Lf2VdusoNr0?g~1DMsY)zdY-63yH!Ii#aWe|;0TO>L7#YlaDrH}xvYXn zh-NYa>O>f_NTTBG=|k0qWH+X?d5@+INsQ}WcI_3z1Z4-%Gj#_{P$0A~cAye`?j0cW z8)hd(V}7rattLUSMvgZ4g96P7n` z^{55A&&29;-P992{yhkGWa3v_Z6iB4a&~NmL)IpC&dsSwe$9jS(4RVJGt=Y!b-O~1 zSCl@wlaba_cA*yt(QvulMcLUuK z>(ys_!{vqKy{%%~d#4ibQ5$yKn6|4Ky0_ngH>x-}h3pHzRt;iqs}KzajS!i!Pqs8c zCP%xI*d=F=6za_0g`{ZO^mAwRk0iwkzKB7D)SaLR0h|ovGF2w9C9g8;f#EtDN*vBP9yl;n=;B2a7#E8(%Bw()z(M$_pu zQ+9uFnlJ!5&$kk^S_+kJ>r9y8MFPpSf9;o8v;ZxsMA!p>eaAIwt5xNiQ|2_ydGkbi zkggG;Xp&I7C8R{>ten^j@MsN#V5JPs1Ezc!74->Nh0a}U){OK@j=OIoY}C7IYYd8-V9 zQ6s?v=Y7(?Y$7=P#Wwub-*0DLqli?I%kT-D^jqK?c2~HEx<2(poRWAUoC}!~6$1=I z*M(IfPmdID8i+5l@=1(+`?i`G_ew=1Y!gF?tFbdgtW2etKLOFoNozkH(i!Qa7(h^| zF`9!VeqQQwM+yO6J`;oWUWq@9l6hP~FiG8-{Pj*T`XI3~s@FfjW2Tl(llpa901$&y`F}K1uZuHEo;=mr+_8d(o z2Be#yWHEN@euC$=VUSB+3A}khJdF$)0r#<5(f3n`kx>ZT8ifaKyX*OhffeHH1?6OM z*-19$j5tMNYQoB)>cGpz@11>J%q4KW`GLNj?uB>LcNg$0G@}XN#Tqf2F5@jv<`|~p zqB^l!%v!g{R_+0GX5z0>3Q~O``%T$NFc==dsPsTj-;{b$XUS0TGoJs2BUA*H;4S?w z|Nigt|F@9hf7QLSo}JPEK#CPgYgTjrdCSChx0yJeRdbXipF(OwV)ZvghYba)5NZxS zm=L8k_7Lb?f8`=vpv(@m%gzsCs9^E$D5Jn+sf}1lep*zz&5V?~qi_@B?-$Vd1ti(rCi*I0}c}slKv@H_+g?#yarVzpYZN zIk21Bz9Z#WOF`JG&TC&C%a*3*`)GJx9I!U8+!#J4}@5rm8*jK%Xg2VLjP-a;H zFydWO;nxOZ&|{yOW;ta$ZU^6*4vFP)idD6M*M0+9buB#hK4z%YTGBdSva?Pvxim2` zF-?QVGuRQ2-1eYzd1Y%}w^`t1S7|{{8=Es#ApC0<;pc$|NJ)IU%WVK+4gnTWA7-t1 z0K{DCESXb}!y_tzrycr^%%|G4T4)`$BC8+qm|n1lS?CO=`V`1T#ykY#5g5$dc$lGt zqGHyw-*Av%C;33nEiU(rU?w^3F46!dEz#cHd3IF<(XCq)>JG?Bi)4v26MQr1A-g5RqhFoPy%^TD3sa|D^9aS>>_2-X2i#? ztVp@ZkyMB;Uo#9s!R!@G#CCaFVaxx*8YYu$kGFk4g3|9t!1nKqOaDBAe;w!(6#w)0 z?{&F2BgctT1=Z;TvjOGL_!}Vlt=kaLA7#W`mv1h%hUg983!wA*K@_r6_cd6o z6LHiCE6qwlt2H&|Ica~%b9C?Z@$dreBNR_!NKcfL)%8kGr7!IVq|^&6PKYK%EhcKu z6+uR*%EOw=rF6Q42Mx|a> z$2XrM*NV2x9ci6|X^eh1UAbJ9Ky!#*Q5w7)#o#%}d!#-^k8To=n8{UU*LmFsS-wRj zi6-p76V6g?If3S&Bj~GW&QI_WtyPY0@u3hjKtqf9`8S!wn{@P&Tc8uu8cf)YmrX7+ zrC+O3V{9}JG6ihA&^2Q7@)Kq)j(Y_oTzsoBUYQDG!}`Ame`bbcr>J-6E%gaBPEDCU zflX#1-)Ih^HJV*lew*N_SdG-4!b2}G8%U&9_V0~Qt?ZS z@H3L&5ybV8X}A@KQADl93H`}0qkNm!jGHkCJUM%r8`mP1nV?Oo%^l;yDnU6IJtbuY z`X2Sf8|r00mB_f)Q0;S{FqS1Yq?otd-BVbw`#@SDd5}n5X4lqdDi1*vtVv8-Zi10q zexCj0eyngrp`UxjEOrdzUt`?%jRlj7zSU-V-%R?y+_w7P7f1ge%t1ozmN+&)%3xQW zT3u@)))(_a<6`lTJd`DIYw>(pkb=PMKvCNEG~zza+LVNqkY^}QoGMVdS0K;gS*A3f z;6Ua!^sSV-try(M^pB6D9dsX}c>$Da#NHucp9vr(fg4pbBR*uPhYq+N>q1X4RSOCl znIQj4=A+y+8{?LQ$3L@(!Yy~~Cu4Sx72*%@dW>eP%Br7=uaynV6Mqa-49A9) z|L&5r=4K5SClwc`!2J|>(#n$4y1>lmR~2Om8q6HkcpK>d(Fk!T^NO?hM4Fc+(5J{` z&K|vrBz;;zWlNO%=a~JkMxMiZa%wYz#G901lw#+2SUaMMHrebb&|1L8tKoGJK*QhJ zU9|WkDy^-4F6U&VYSc3ScHDk@kV^0801#I|-pSK%az5=DwI}gMm)@s2O+-ESTk?QY z;y9gyucaXO(Cc+cd{B>2)euMHFT71$a6DssWU>>oLw4E-7>FC-YgZH1QAbRwmdahD zO4KAeuA^0q&yWS|zLTx%(P4VOqZv-^BO`0OFAXdBNt9>LAXmPALi3b|gt{b?e-$z0 z4n7H$eg6y_zs(c>*4FT!kN*$H`43~1p!g;IZ8-mYbUPTejaLW#BZnAPFES?ApM{TQ zE*TC%O8)apqcX|PrNjIZE-z{q`I(LwIE0kf=PLjExEX>)oIu><<@lt>-Ng9i$Lrk( znGXl|i4dP;Mt^-IbEp7K0e#*c7By@gCo@VQIW$93ujLL`)lMbA9R?C_5u~7^KopaAMj#6&>n-SOWlup_@{4 zcJ?w_!9JKPM=&Bd#IQ37F*x39y!azm$;~IRlkm>bHdABcNwW-TdDKD$pkD{j6A8d* z{vP~|<}bj_Oz#83K$ieRtsA4a@4a5cRjJ}A01{PgxXn3;fx)5ElMEPwDX_mW9)9oB z*;scve~v#HHqUj3KdC$tdV3&0)Whkp-=hKKz{SzD7g0@N!wyv;ZAime7AjB7&)!)5 zp_iVblaf)%agwJqOG2e7WTCM1&khq`{b>fN4n8hOJbvO?Y;60>LIwagLXWC@@0RSR zo%lPo1cUU=g$ahJ8D=;`v~ORUSl(1-&a@yTAC5Y8E892@{P@MM=GXUGpBSXSbSs!N z;L~0D_s7{+^F6c!WW+^yz5~o7eWtsOE}8{hKaFlHgnyBeUJ8Zz2$k7Lrh?NuMU|No zVvsq@57)8zin;&ckR1;*Z%(xH2lBw z`x%N;|H1En8au588bPDxP^$kfpO!bIzz>K=5Jiq9Rg(NGde0g!rKagLa+&yC)jg7y zq}~2IH)N*FJC31qrIH-2;%3^F?=bDD^U2Y;%ftN(v71oY;od+vh!!2z^}GHR$43rg z0In@ki}TglIsMU^O1(SiLK#oiuyw zB>-@z?&uW`ILoPupw0_cs?C|2YoX&87~us+ny%eo{A!3M<-7O7mHUBCgA~{yR!Dc^ zb= z8}s4Ly!GdxEQj7HHr<}iu@%Lu+-bV>EZ6MnB~{v7U59;q<9$h}&0WT;SKRpf2IId ztAjig0@{@!ab z{yVt$e@uJ{3R~8*vfrL03KVF2pS5`oR75rm?1c`@a8e{G$zfx^mA*~d>1x`8#dRm) zFESmEnSSsupfB>h7MipTeE!t>BayDVjH~pu&(FI%bRUpZ*H615?2(_6vNmYwbc^KX4HqSi!&mY9$w zpf%C6vy@O30&3N5#0s_!jDk|6qjb-7wE3YT3DA7q3D`Q&Y*y>XbgE7=g#rPx1hnf8 zTWd{IC!Iysq*vZup5VGrO)UM<3)6raR`rOwk(!ikf3XPp!n|gz0hS*P=VDXAyMW(s zL??-`&IusEuOMrz>m(A1W5Q~>9xJwCExAcMkOBD` zD5BJSadd{0u}%z4r!9qA`FW4;Ka_Qk>FcHxiucGw4L9qhtoge|ag8jbr`7LHSbVQz z6|xUo*^LV1SLxS>?D`m=g{8IC&1YF$e}VRGD#ZOc_15QW%J@FbEj8tE-nGxo4?X02 z@|q#k*G4xMW>q84Xc09pRj@>Hz8t^fMm3n&G;Al6KU*;=W`7Q{$^|=bnZiJ7?(s)@ zB`vW>#zJ{}!8=*|?p(~fcXSanO^j8+q7V!q16*ic!HLRdz0TzNI6}m+=OKd2b8KX< zAcDTj*%~vQlcO+%@H01gjv-1zZaOXVoM*t-+KXTR#NoTf-#{dQAm?GqK6q8Ta zu3xW?t=NE$EfYa#=0HofLn5~c#m-U#Ct_r6~X-pg6k*F zYIP7De52BBwcAnK?O(j?YEs1;q60!-!hTuKzw3T;XcA_w5HvU;tO~}byLA^cggu8i z-IP@pxFjTy&ie28m}j66dm@g78xK7aG{QSR^bAcY+W*xWu;G~I08sf(GK4>K-cbfJ z-%v9DGR77He<291M~=fg>>9&NFQlboP)pC6fT;{>_!lM`A&&HWIMd)Y6e@IL;nvRdBE*Tn({&3{-XJ9helJa{G51Ck}-_Y=5C|fEo z)7fZlsHxN&SY&ZLTdYuBBZnwIh0#VTzmyK>U0|r&SXb&GP0m)1dGV8z(^x6s5yQ-z zEyniK${#U@Y7p@Yxx}E+jA?1@{=|e6UM;iyai=0=aItVvqieogZUq@sio2#9NLW~L z{w@^H!HEGU;>;T0lu{Ad20Hr6u;?-9YHKvkjEc)}wsb4Y-ArRK8`24uBT8N)8m%Ee zYJX21)|e{peL26}VUUKYQ3L@NSe8rEbN#AIo$tjJm-$B|IJU?mu(h$Sq`XNY0@NhY z0?WeMtPwP)sUdk}dWA4qBUV^x>P|is-kPgVe)*WV>dKDL>gOq1 zUYw(nU|N#dw>97A_(c3?VA_zDfF{^A1eE#8Bucd^ON(sv-{tc@&i)Y)3V~o7U~+AA zOwnXB5`WN^z$z<9^@(?LY%7?y5X_C(j1ip-Ug^f7Tt6suI3&a=&~#EJegG4r2^tKz zJoEXCVOc1QdOSNHp2d;t&smxL%CfK@mSl)Ky}`!6kCsi#7s5&G2Q!sM9S6o)&mdx% zz|2M~pav2;Th=DTN5yB@6HFAO!pl-y+tEJsh}(? z!tIyg01O*w@mWxsFhHMi7%Gqz!v(Osc5WxK+^1PGfsozw)FE}VIxk9GexmAohPNAF*SAjxG3Al#(xQoYXdI}TR zoCHAFS6+LDqsP8L1SZH{RxJjFK_=vy4nNH^?M!OsQWe^qC~$c1r&y`H9n5;D z2F$t-Htc%2@K(>opJHE{NytI2<_J<6Kz*p$wtKUTEH}zITx?H0L%!5%i@!rLphSBrkFs>jscP6?HVQovX8!~b~ZY|0h%&souT7e5nD@OxuSgC zVW*eo0B|1POwg7;6fJSUC`g+`1%XQvwpRc*&|AtV*h!#5nQM(@m!K)-Qop!Rt3F`a z9HUO zF3w{uI_==EpjFQWV4boF^A?wc@@@U+KrKPjn6sK{OLu-~1UloSqt-aHYo*^@kQy2+ zH(9*-mFz?YV4cL7EW)9hsdmG{5jaYXLvm*&3PZ4y?8z`$9z6`q9fgsJm@*W$-QSzu zut}57hroSbTd=&RJpuy#?K?A6!-;_MowpK8eb~5T-^eye%3O-T^ktSMbd%PT0j-B?#yAKr37u%gB z*2)WJMw6Y)6BvY$JjD`(06ci7u;u$hv}gN5oS&Q^*y$J6L)0#BD<>XL|;pZgtZaxp3~$0zxA(;6Qr_AP$?8l@S)C^Hoaz#rQFK^lA}3&)Gr}Fsca? zK>9BkVcl;c*E2P9UMppEIB&38dL9R?Xg9N{Nl~4*w!qsZJElz}Xc9gz#}cwnP4u{+ z6VNTEx*>u67?3bn{sWk*P`1_$YfsB+)Ax0+jt|)0p&VS?N0k8IAp2KH_#eY3I#{Hw zB$vObUDtXyZX)*wVh*@BefnUej#jv@%uiA=>ngX0kQXaz>8(WM)fX~v__@I}7|!Il z@J%r#I!JqqFwGd4JPhmDmL>1Bh}nn_BE;hgKUesNOf9zQhiuhn%4B}O8jnxEwJiQFDaiiuXw2sb?*8a}Lr;_#7+IPfIjhVDhazSpbQZECL+4)p8lO;)!y>Rt=0X*;O# zX{s(p-*d{#{Y3gVhL;A{4a(Z5sIfpk;WMCqdFA&Mb7mp;YMXhBF@p`}$ShAug+bo`;<9fm!~F z-;1yCj$GQ^mzucrfuatilXrYLr)`izjn_m(f~);txN?D7d?Kg4wDuPXilVyeVwjzf z=4Kewf=u}X_H*viVfPWZW?Sqa3G#h3|;b!Q7>BRc7-Wox0}&>}Lqo=0v;T_i~% zqB&h;14|~nK{W0N=$obGP@O%(c8SraYS^qiu%Q`B zBHdA!`Vk7#Bz*@_3eE#bizLzjBV;F0vfSA~+7@8+F{$7Y?fwI~Pp_X`2ORgqW6g@2 z{cQV!niSsMEVr1IaeRAj8~|*4yW~X5$6o`crw4uTHhgPs^qAk?9UPu;xy5wh2^jZ; z)@27Q=QKa?8w7_C0|u`@k=%b9Ce$D7x42CdLsckF2<$wLuV2kpik8PXex2^Co$n2o z)l#H*;#>?yrPw0x6LI@x(X$nezCBa0Obi%|I5ZV|4bJSPtNHjDkS|3S?fiv(i_(n* zFbve0g!B0!MMmakRsgg_if8nwImb=kk%|s+08xGQ)J?vpkdaya3UD|RJK+LQ72|g> zc4LnwInx!2pN-5Yvp7rvRF#B=(ZO8gyVB^0Dh#ZdHA2BjjppfV<=2Nm#w_t{%6O$W z`-?7N?LwL0DWgK0Y7L#ChSHfa{=DOpJpl8L@V70cd%ei)n%SQO;Z+Xw#li#%LUfbs z&hP%UzN(qM3cw#bWQS6_B@>1^ea-AqNA12xoiQeb_Zdtf>yHljqeIHqlyC^gzH)h1 zstXTFEb0r=l9;><<$a}YWlscH7VW_xeKVZ#*#v#HiuUOs7PPj8ml4#!BiGEK)kDpO zX=2mU0ZuIDDnhfV7v_Rs)0R#ff6I6_|MrzV(R$3Nt#S7D?GQy6?a^WRvA@r2~?7f~s99*9;fuqJ(843U`hRl2O|sk>J@WMsR2O zwyZt$@J)DnSUNkF@B3MPNz|<@`72{M*S5d<1Vkg+G=q~u{8OP84Yh6VCE5pNC*#m> z*jzHy5Tc82sBVw+6W7DoR5@LXZ|+>;)Q%czg%8pyMyeE2-)R^oHg~SrO~#I8MxNc> z6pWT&F&H1mX7#2@mBY>#rRoFKszT z(gvV#j3x|7sF|Dt0*CgsJTdH1R!>inYZWp*2RDbjjQCP98L_ds!$x&{t85NRYk4ii ztJ3HyC8h2A2&`kq^Cfci>N*r&btHg_|v6=s|v=(-MQ zK4kjqoI^~y`j9poC2r{Izdlehm8!AcMP^+SwDUce1Zon(%YvxK)x|rXsJRlO?-K91 zMsmHgI&PmqT_W}C0mdA_6L!EEjgJzidRvTN;vQRJ-uBl#{dEeN?24PRwx)7c5kF^ut=M0)e@zr?z_vpYf=%;;@UYF9>9-->Qf2FW*# z5*#VFB$$-k(zphh4sAElMiLbp`$+SKm*{l6qX;Q8GZ7b|J>OhC!yg$}8dt$dx3E8b z$FlaM*K@6mSsYCoe#*QjLEB3|_Vs4GbZI#!>Ya}dzh%uMn}sw0gFQQ{+V+e|_`q)M3nK27)nAqQ-viJoPHUKdr9HN`v0 z+tZo0ORLuv_d)x}gO|~s(H!12RM(aMfqLG>KSH#kGxC{sUUj>FUC(6;ds1cOjeDYu zOrd>q@bNFq5?0s&@5nbF3-rw{{V&YYf3o_9|K-X4k861UwZ&C2bH+A7^%7nizU>b? zC2@*VlrqprJiv$rx{+^+Op9i3RM;IHq@a;34=Gn%B+rXMZi=UsHC@TEFk4{*fs96p z)wNUY?AhVkdLGQmPESuh@-!iqSZrnxIT~Mon)J+i+B~9VdL8QE`^4=2@lNaKluUVx z_^i7~5E4dN4&gVMi%;7ast@WIY21Q`+^iTC*Gx@IMVYB`BLFHzPh{Fpc6LKZTk@>P zquo2E*Pgq(0MX>h>4)YaJYbIK&V?-W}JfL@&R0I2)TOA!Teg zNa4DBO&)`Nn0$Inb|d8ea|)qqOLYVbQIBRC4T4E<5#Nzc2 z57|Bq7mYsW8y?uLA$XMj%OeK+1|DAKcLYB98-vDP<3*+SKYcPcOkm&}H|!{9l*9%L zbiYJYJ^)Cql-&wPwABGD>Ai7SUXe15m zIr^wNEU$9)D6@atm z(w(1~GuLpHi?JGgIBj`Ovy;j4M`XjrCNs?JsGh1zKsZ{8 z@%G?i>LaU7#uSQLpypocm*onI)$8zFgVWc7_8PVuuw>u`j-<@R$Of}T`glJ!@v*N^ zc(T~+N+M!ZczPSXN&?Ww(<@B=+*jZ+KmcpB8* zDY_1bZ3fwTw|urH{LLWB;DCGzz$jD|VX#Af@HC%BktA8F7VJSy&!5iTt};#U^e0_q zh6j7KCTInKqriZ1`BiF3iq2LWk;gyt0ORIFc4Mi3Bx`7WEuFq{u^C49-SYVjnv!_40m1>7x*+<8~Xkq?056 z!RBfE@osP%SxzOw>cLAQ$bioAOC0V!OzIXIc};)8HjfPtc~8tnah$PtoAz`4k)7$FDUc2O@D)g_uAo&nXMymK$##V?gYUPt^l zj{6NFDL(l-Rh(xkAHP%bBa=($r%3Y~jB!eQ1Smuq2iuQ|>n%Y=p(26SE5gFu11*Q< zaPN5G^d;Iovf`VY&Gh58z~%JpGzaeUz6QoBL^J%+U4|30w7Q&g9i}}@l61eKEfCgo zST6qMxF_Eaj7;0OC)TSU{4_m}%FOa6B{AxS$QIcmmG~IVjjf;7Uk!HBtHfm{%LsLb zu8~5VQFyOZk&!VY(wxL__haJ;>Bj?g&n`+i&=X{unJmv&0whCitWfGlOr6+Tc-lMZ z(ZRXqC-=O+GAvTXKViA9vdwu{aifhk$tYh~-9BScg!Yr*M2zw&9`pHMxHGh`dUH-1;~^6lF@ep;X9PjQ!rqmXNWJ?#P-qb%*TB%xe&3 zX*5V>xuW7)$3!Yc$y>cwBqd8+p+u>WS7p7~O80ipG{(a*#=NJ`^Ld6k-`|;Y&htFy zIi2(Sm)4eD=o+CGo~M3%qF|O9P0+ahmc%EklI?NgX05W3+OdS`_Rd#wg-}hd1&txU5wXy zy`x)05?WVZvELw`XWetIAg6$|(^4ntaE;=f$Wcpwbxm7?bLDnPs-1!bRoMcy!EeOh zpIv8ewDzcIU}mv1NxV!&(Wf7~_kqGAk=2=j&O5FA)z2!APCcDQPnIaiqMkVT4fUyX z))R|WvOJyzcU6d=z0q8JDt42*`js4g+_t{YP7lVguX+vhEejJ3TAIo*Z6jizHm#S- zZT_}-STQAa-0Gn8+RmR7V}{Ns1@jJ{^Sb!9&RSXXP;^ep)r6;&PW++~XYXC9a=zSF z?sp(JQo&MROb~b1Y*Xw4!P)>PHT>Z<)*U=Ax_75^OUw97pNudbxS1XPtNrIg zQ5YB77E@i7$2Ia}(^JcCi@OX`9a|m}PY%-th2m~y+)eCl>fTVjCP^lDOBLyhg1DZ+ z)~G{&OkDc$!;t~`gq(wz@qW3lh9B^ic$>-h#nV!H8d#l+>C(M%g}u2g=I#&W|L!VD zqHYoQkBW;`r|fW02u{7X!X;}T7X4iAaWzkeOh}7&o!F1qt4#$1|BDF;(2VlgEqJ$F zy8Ba-y(%fs`MzpvyXlQLEhS^ed$7Va2hO%?$-D>^*f$b)2Hx;}Ao$UqFt7l26<7eP z!{!C7PVrq>=794Zqmc z%LKkzIBZq@%Ja8EkH}?>c5ILG(EAMS*JHu?#9_7TsELw)8LZzN>f2Y6YN{AJC?34> zh42sPa1%2JpCeS9&E1URm+Pb}B>A1M`R{+O+2~}c(@^1Rf&J9p(4QqHl;E^4w5;I5 zM{?(A^eg*6DY_kI*-9!?If^HaNBfuh*u==X1_a?8$EQ3z!&;v2iJ``O7mZh%G)(O8 ze<4wX?N94(Ozf9`j+=TZpCbH>KVjWyLUe*SCiYO=rFZ4}S~Tq|ln75Jz7$AcKl$=hub=-0RM1s(0WMmE`(OPtAj>7_2I5&76hu2KPIA0y;9{+8yKa;9-m??hIE5t`5DrZ8DzRsQ+{p1jk-VFL9U z2NK_oIeqvyze>1K%b|V?-t;Wv`nY~?-t;tMC4ozyk8CR(hoZTno3!*8ZTc15`?MFf zDI892&g&3lshOEv4E@w-*_%)8C_<&HhV`0D5lN$WT4Q^UWHNSAE+RZe(o z%bqR^hp1IsDr47e^AajFtlppT)2F6yPcrWO9{Kw{o=P6y^HOW$Wqd_)_fwzn`ikZl zOGVc0+S(*=xZ_KbL0Nr`Sx$$CWEbw$52udl1f=X6CZEcFMA*nl>`0gn4&tc5^`!!)tGw<}^Q>P7E}$ zialDUofH*XcB3r9@tA@lnS}dA(@nK_xuw0b;FPUnNGD0;MIySCw=cSzB#=3>F37V-nni3UNB)-;;Gkk;3l9fh6FIjSZU zk=Eo2a`6i7@i*4>ym5`R?i-uZFv6+iX*Gi^I}ZU1OrLAX8aGiT@`*YnjeF>}$U}ORP`+EY5`eqVC_&4yG z;Tp>+2QbZ?lt1GB+D}q14W3dWP8lWnN zf(nlT6+XW&(zme{FbyDpP^NakA<~TK=Y}H^eS%2rt0v8Lr)B}@B!cTvC=9FM;7q4@ zf*;vb4HG>RFpY5?vFCp27VEnVIGx~-na6biU4{+UoYe=}^R#_My6wT$5d&r*=kpAA zu;=-c0|~yqi(N8&*H;aNfhyey+HHQ7J_qae*_CgG2V8j=Tq936S0DC8r3BXBql3Gz z0pLo_`|4Q+oY3rPBNaLmL{QM};9dke>ujP^j@z-N;fNlKb|edn>)YaafDaJ>GWKP$ z5}l&#$QFhN!CMT;WH&z-5E)kvM|36lV!^#3z{@2FF>HsgUO4PMqO#U$X%+U>K!xJ@ zBFs|+woG_9HZQs_Tw*vnCPGhlXG@>y|6pJT$I67!aP&b0o$AF2JwFy9OoapQAk>k7 z**+$_5L;5fKof<;NBX%_;vP@eyD=Z0(QW)5AF7 zp|=tk3p?5)*e~Inuydz-U?%Kuj4%zToS5I|lolPT!B)ZuRVkVa>f*-2aPeV3R79xh zB)3A$>X~szg#}>uNkpLPG#3IKyeMHM*pUuV5=-Jji7S6PSQ9oCLo{oXxzOZfF$PP) zrYwlmSQ-~n94uO3CD{K0QTmj@g%Yzn7_xQ4fTduU0Yqvln`e_`CdXH5iQ5qRr1 zBC;}%YZ2!4I>*=sR)O~jBPx6sxmIEBnq)s-fHz_y0z8-gPl2Us4BiBXNR5CIF!YR@ zb9B305SilU*@4|+ x6JBtc8JSt5M0pkooaq!^FqtuD_KdXXTo>Mw54>`rP&>h&58!3a6l6r9{sG7g--!SK literal 0 HcmV?d00001 diff --git a/benchmarks/gradle/wrapper/gradle-wrapper.properties b/benchmarks/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 00000000..1b16c34a --- /dev/null +++ b/benchmarks/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,5 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-6.1.1-bin.zip +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/benchmarks/gradlew b/benchmarks/gradlew new file mode 100755 index 00000000..2fe81a7d --- /dev/null +++ b/benchmarks/gradlew @@ -0,0 +1,183 @@ +#!/usr/bin/env sh + +# +# Copyright 2015 the original author or authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +############################################################################## +## +## Gradle start up script for UN*X +## +############################################################################## + +# Attempt to set APP_HOME +# Resolve links: $0 may be a link +PRG="$0" +# Need this for relative symlinks. +while [ -h "$PRG" ] ; do + ls=`ls -ld "$PRG"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi +done +SAVED="`pwd`" +cd "`dirname \"$PRG\"`/" >/dev/null +APP_HOME="`pwd -P`" +cd "$SAVED" >/dev/null + +APP_NAME="Gradle" +APP_BASE_NAME=`basename "$0"` + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn () { + echo "$*" +} + +die () { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "`uname`" in + CYGWIN* ) + cygwin=true + ;; + Darwin* ) + darwin=true + ;; + MINGW* ) + msys=true + ;; + NONSTOP* ) + nonstop=true + ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then + MAX_FD_LIMIT=`ulimit -H -n` + if [ $? -eq 0 ] ; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ] ; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin or MSYS, switch paths to Windows format before running java +if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then + APP_HOME=`cygpath --path --mixed "$APP_HOME"` + CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + JAVACMD=`cygpath --unix "$JAVACMD"` + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` + SEP="" + for dir in $ROOTDIRSRAW ; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ] ; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@" ; do + CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` + CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition + eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` + else + eval `echo args$i`="\"$arg\"" + fi + i=`expr $i + 1` + done + case $i in + 0) set -- ;; + 1) set -- "$args0" ;; + 2) set -- "$args0" "$args1" ;; + 3) set -- "$args0" "$args1" "$args2" ;; + 4) set -- "$args0" "$args1" "$args2" "$args3" ;; + 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Escape application args +save () { + for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done + echo " " +} +APP_ARGS=`save "$@"` + +# Collect all arguments for the java command, following the shell quoting and substitution rules +eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" + +exec "$JAVACMD" "$@" diff --git a/benchmarks/gradlew.bat b/benchmarks/gradlew.bat new file mode 100644 index 00000000..9109989e --- /dev/null +++ b/benchmarks/gradlew.bat @@ -0,0 +1,103 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto init + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto init + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:init +@rem Get command-line arguments, handling Windows variants + +if not "%OS%" == "Windows_NT" goto win9xME_args + +:win9xME_args +@rem Slurp the command line arguments. +set CMD_LINE_ARGS= +set _SKIP=2 + +:win9xME_args_slurp +if "x%~1" == "x" goto execute + +set CMD_LINE_ARGS=%* + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/benchmarks/settings.gradle.kts b/benchmarks/settings.gradle.kts new file mode 100644 index 00000000..e9309622 --- /dev/null +++ b/benchmarks/settings.gradle.kts @@ -0,0 +1,31 @@ +includeBuild("../build-support") { + dependencySubstitution { + substitute(module("godot-kotlin:build-support:0.1.0")).with(project(":")) + } +} + +includeBuild("../godot-kotlin-editor-plugin") { + dependencySubstitution { + substitute(module("com.github.raniejade:godot-kotlin-editor-plugin:0.1.0")).with(project(":")) + } +} + + +includeBuild("../") { + dependencySubstitution { + substitute(module("com.github.raniejade:godot-kotlin-gradle-plugin:0.1.0")).with(project(":godot-kotlin-gradle-plugin")) + substitute(module("com.github.raniejade:godot-kotlin:0.1.0")).with(project(":godot-kotlin")) + } +} + +pluginManagement { + resolutionStrategy.eachPlugin { + when (requested.id.id) { + "com.github.raniejade.godot-kotlin", + "com.github.raniejade.godot-kotlin.plugin" -> useModule("com.github.raniejade:godot-kotlin-gradle-plugin:0.1.0") + } + } +} + + +includeBuild("bunnymark") \ No newline at end of file diff --git a/build-support/src/main/kotlin/godot/codegen/APIGenerator.kt b/build-support/src/main/kotlin/godot/codegen/APIGenerator.kt index f879885b..1cdc2fec 100644 --- a/build-support/src/main/kotlin/godot/codegen/APIGenerator.kt +++ b/build-support/src/main/kotlin/godot/codegen/APIGenerator.kt @@ -564,113 +564,132 @@ class APIGenerator { if (method.hasVarargs) { val nullableAny = ClassName("kotlin", "Any").copy(nullable = true) builder.addParameter("varargs", nullableAny, KModifier.VARARG) - } - if (!method.isVirtual) { - builder.addStatement("val self = this") - builder.addCode("return Allocator.allocationScope {⇥\n") + if (!method.isVirtual) { + builder.addStatement("val _args = mutableListOf()") + parameters.forEach { parameter -> + builder.addStatement("_args.add(Variant(%N))", parameter.name) + } + builder.addStatement("varargs.forEach { _args.add(Variant.fromAny(it)) }") + builder.addStatement("val _ret = __method_bind.%L.slowcall(this._handle, _args)", method.name) - val ret = if (parsedType.isVoid) { - "null" + if (!parsedType.isVoid) { + if (parsedType.fqName == "Variant") { + builder.addStatement("return _ret") + } else { + builder.addStatement("return _ret as %T", returnTypeClassName!!) + } + } } else { - when { - parsedType.isCoreType -> { - if (parsedType.isPrimitive) { - if (parsedType.coreType == CoreType.STRING) { - builder.addStatement("val _ret = alloc()") - builder.addStatement("val _retPtr = _ret.ptr") - builder.addStatement("checkNotNull(Godot.gdnative.godot_string_new)(_retPtr)") - } else { - val primitiveType = when (parsedType.coreType) { - CoreType.INT -> "IntVar" - CoreType.FLOAT -> "DoubleVar" - CoreType.BOOL -> "BooleanVar" - else -> throw AssertionError("Unknown primitive type ${parsedType.coreType}") + builder.addStatement("TODO()") + } + } else { + if (!method.isVirtual) { + builder.addStatement("val self = this") + builder.addCode("return Allocator.allocationScope {⇥\n") + + val ret = if (parsedType.isVoid) { + "null" + } else { + when { + parsedType.isCoreType -> { + if (parsedType.isPrimitive) { + if (parsedType.coreType == CoreType.STRING) { + builder.addStatement("val _ret = alloc()") + builder.addStatement("val _retPtr = _ret.ptr") + builder.addStatement("checkNotNull(Godot.gdnative.godot_string_new)(_retPtr)") + } else { + val primitiveType = when (parsedType.coreType) { + CoreType.INT -> "IntVar" + CoreType.FLOAT -> "DoubleVar" + CoreType.BOOL -> "BooleanVar" + else -> throw AssertionError("Unknown primitive type ${parsedType.coreType}") + } + builder.addStatement("val _ret = alloc<%L>()", primitiveType) + builder.addStatement("val _retPtr = _ret.ptr") } - builder.addStatement("val _ret = alloc<%L>()", primitiveType) + } else if (parsedType.isEnum) { + builder.addStatement("val _ret = alloc()") builder.addStatement("val _retPtr = _ret.ptr") + } else { + builder.addStatement("val _ret = %T()", returnTypeClassName!!) + builder.addStatement("val _retPtr = _ret._value.ptr") } - } else if (parsedType.isEnum) { + } + parsedType.isEnum -> { builder.addStatement("val _ret = alloc()") builder.addStatement("val _retPtr = _ret.ptr") - } else { - builder.addStatement("val _ret = %T()", returnTypeClassName!!) - builder.addStatement("val _retPtr = _ret._value.ptr") } - } - parsedType.isEnum -> { - builder.addStatement("val _ret = alloc()") - builder.addStatement("val _retPtr = _ret.ptr") - } - else -> { - // most likely an object - if (parsedType.nullable) { - builder.addStatement("var _ret: %T = null", returnTypeClassName!!) - } else { - builder.addStatement("lateinit var _ret: %T", returnTypeClassName!!) + else -> { + // most likely an object + if (parsedType.nullable) { + builder.addStatement("var _ret: %T = null", returnTypeClassName!!) + } else { + builder.addStatement("lateinit var _ret: %T", returnTypeClassName!!) + } + builder.addStatement("val _tmp = alloc()") + builder.addStatement("val _retPtr = _tmp.ptr") } - builder.addStatement("val _tmp = alloc()") - builder.addStatement("val _retPtr = _tmp.ptr") } + "_retPtr" } - "_retPtr" - } - if (parameters.isNotEmpty() || method.hasVarargs) { - if (parameters.size == 1 && !method.hasVarargs) { - val parameter = parameters[0] - //builder.addStatement("val _arg = Variant(%N)", parameter.name) - builder.addStatement("__method_bind.%L.call(self._handle, listOf(%N), %L)", method.name, parameter.name, ret) - } else { - builder.addStatement("val _args = mutableListOf()") + if (parameters.isNotEmpty() || method.hasVarargs) { + if (parameters.size == 1 && !method.hasVarargs) { + val parameter = parameters[0] + //builder.addStatement("val _arg = Variant(%N)", parameter.name) + builder.addStatement("__method_bind.%L.call(self._handle, listOf(%N), %L)", method.name, parameter.name, ret) + } else { + builder.addStatement("val _args = mutableListOf()") - parameters.forEach { parameter -> - builder.addStatement("_args.add(%N)", parameter) - } + parameters.forEach { parameter -> + builder.addStatement("_args.add(%N)", parameter) + } - if (method.hasVarargs) { - builder.addStatement("varargs.forEach { _args.add(it) }") - } + if (method.hasVarargs) { + builder.addStatement("varargs.forEach { _args.add(it) }") + } - builder.addStatement("__method_bind.%L.call(self._handle, _args, %L)", method.name, ret) + builder.addStatement("__method_bind.%L.call(self._handle, _args, %L)", method.name, ret) + } + } else { + builder.addStatement("__method_bind.%L.call(self._handle, emptyList(), %L)", method.name, ret) } - } else { - builder.addStatement("__method_bind.%L.call(self._handle, emptyList(), %L)", method.name, ret) - } - if (!parsedType.isVoid) { + if (!parsedType.isVoid) { - if (!parsedType.isPrimitive && parsedType.isCoreType && !parsedType.isEnum) { - builder.addStatement("_ret._value = _retPtr.pointed.readValue()") - } else if (!parsedType.isCoreType) { - // object - if (parsedType.nullable) { - builder.addStatement("if (_tmp.value != null) { _ret = objectToType<%T>(_tmp.value!!) }", returnTypeClassName!!.copy(nullable = false)) - } else if (!parsedType.isEnum) { - builder.addStatement("_ret = objectToType<%T>(_tmp.value!!)", returnTypeClassName!!) + if (!parsedType.isPrimitive && parsedType.isCoreType && !parsedType.isEnum) { + builder.addStatement("_ret._value = _retPtr.pointed.readValue()") + } else if (!parsedType.isCoreType) { + // object + if (parsedType.nullable) { + builder.addStatement("if (_tmp.value != null) { _ret = objectToType<%T>(_tmp.value!!) }", returnTypeClassName!!.copy(nullable = false)) + } else if (!parsedType.isEnum) { + builder.addStatement("_ret = objectToType<%T>(_tmp.value!!)", returnTypeClassName!!) + } } - } - if (parsedType.isEnum) { - builder.addStatement("${parsedType.fqName}.from(_ret.value)") - } else if (parsedType.isPrimitive) { - if (parsedType.coreType == CoreType.STRING) { - builder.addStatement("_ret.toKStringAndDestroy()") - } else { - if (parsedType.coreType == CoreType.FLOAT) { - builder.addStatement("_ret.value.toFloat()") + if (parsedType.isEnum) { + builder.addStatement("${parsedType.fqName}.from(_ret.value)") + } else if (parsedType.isPrimitive) { + if (parsedType.coreType == CoreType.STRING) { + builder.addStatement("_ret.toKStringAndDestroy()") } else { - builder.addStatement("_ret.value") + if (parsedType.coreType == CoreType.FLOAT) { + builder.addStatement("_ret.value.toFloat()") + } else { + builder.addStatement("_ret.value") + } } + } else { + builder.addStatement("_ret") } - } else { - builder.addStatement("_ret") } - } - builder.addCode("⇤}\n") - } else { - builder.addStatement("TODO()") + builder.addCode("⇤}\n") + } else { + builder.addStatement("TODO()") + } } builder.build() } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/FuncRef.kt b/godot-kotlin/src/nativeGen/kotlin/godot/FuncRef.kt index 268e2c61..090f82fe 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/FuncRef.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/FuncRef.kt @@ -39,16 +39,10 @@ open class FuncRef( } fun callFunc(vararg varargs: Any?): Variant { - val self = this - return Allocator.allocationScope { - val _ret = Variant() - val _retPtr = _ret._value.ptr - val _args = mutableListOf() - varargs.forEach { _args.add(it) } - __method_bind.callFunc.call(self._handle, _args, _retPtr) - _ret._value = _retPtr.pointed.readValue() - _ret - } + val _args = mutableListOf() + varargs.forEach { _args.add(Variant.fromAny(it)) } + val _ret = __method_bind.callFunc.slowcall(this._handle, _args) + return _ret } fun callFuncv(argArray: VariantArray): Variant { diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/GDScript.kt b/godot-kotlin/src/nativeGen/kotlin/godot/GDScript.kt index 4831c119..419c655b 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/GDScript.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/GDScript.kt @@ -50,16 +50,10 @@ open class GDScript( } fun new(vararg varargs: Any?): Variant { - val self = this - return Allocator.allocationScope { - val _ret = Variant() - val _retPtr = _ret._value.ptr - val _args = mutableListOf() - varargs.forEach { _args.add(it) } - __method_bind.new.call(self._handle, _args, _retPtr) - _ret._value = _retPtr.pointed.readValue() - _ret - } + val _args = mutableListOf() + varargs.forEach { _args.add(Variant.fromAny(it)) } + val _ret = __method_bind.new.slowcall(this._handle, _args) + return _ret } companion object { diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/NativeScript.kt b/godot-kotlin/src/nativeGen/kotlin/godot/NativeScript.kt index 35d91712..ca967ace 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/NativeScript.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/NativeScript.kt @@ -159,16 +159,10 @@ open class NativeScript( } fun new(vararg varargs: Any?): Variant { - val self = this - return Allocator.allocationScope { - val _ret = Variant() - val _retPtr = _ret._value.ptr - val _args = mutableListOf() - varargs.forEach { _args.add(it) } - __method_bind.new.call(self._handle, _args, _retPtr) - _ret._value = _retPtr.pointed.readValue() - _ret - } + val _args = mutableListOf() + varargs.forEach { _args.add(Variant.fromAny(it)) } + val _ret = __method_bind.new.slowcall(this._handle, _args) + return _ret } fun setClassName(className: String) { diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Node.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Node.kt index de3a1ef8..94704375 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Node.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Node.kt @@ -791,17 +791,11 @@ open class Node( } fun rpc(method: String, vararg varargs: Any?): Variant { - val self = this - return Allocator.allocationScope { - val _ret = Variant() - val _retPtr = _ret._value.ptr - val _args = mutableListOf() - _args.add(method) - varargs.forEach { _args.add(it) } - __method_bind.rpc.call(self._handle, _args, _retPtr) - _ret._value = _retPtr.pointed.readValue() - _ret - } + val _args = mutableListOf() + _args.add(Variant(method)) + varargs.forEach { _args.add(Variant.fromAny(it)) } + val _ret = __method_bind.rpc.slowcall(this._handle, _args) + return _ret } fun rpcConfig(method: String, mode: Int) { @@ -819,32 +813,20 @@ open class Node( method: String, vararg varargs: Any? ): Variant { - val self = this - return Allocator.allocationScope { - val _ret = Variant() - val _retPtr = _ret._value.ptr - val _args = mutableListOf() - _args.add(peerId) - _args.add(method) - varargs.forEach { _args.add(it) } - __method_bind.rpcId.call(self._handle, _args, _retPtr) - _ret._value = _retPtr.pointed.readValue() - _ret - } + val _args = mutableListOf() + _args.add(Variant(peerId)) + _args.add(Variant(method)) + varargs.forEach { _args.add(Variant.fromAny(it)) } + val _ret = __method_bind.rpcId.slowcall(this._handle, _args) + return _ret } fun rpcUnreliable(method: String, vararg varargs: Any?): Variant { - val self = this - return Allocator.allocationScope { - val _ret = Variant() - val _retPtr = _ret._value.ptr - val _args = mutableListOf() - _args.add(method) - varargs.forEach { _args.add(it) } - __method_bind.rpcUnreliable.call(self._handle, _args, _retPtr) - _ret._value = _retPtr.pointed.readValue() - _ret - } + val _args = mutableListOf() + _args.add(Variant(method)) + varargs.forEach { _args.add(Variant.fromAny(it)) } + val _ret = __method_bind.rpcUnreliable.slowcall(this._handle, _args) + return _ret } fun rpcUnreliableId( @@ -852,18 +834,12 @@ open class Node( method: String, vararg varargs: Any? ): Variant { - val self = this - return Allocator.allocationScope { - val _ret = Variant() - val _retPtr = _ret._value.ptr - val _args = mutableListOf() - _args.add(peerId) - _args.add(method) - varargs.forEach { _args.add(it) } - __method_bind.rpcUnreliableId.call(self._handle, _args, _retPtr) - _ret._value = _retPtr.pointed.readValue() - _ret - } + val _args = mutableListOf() + _args.add(Variant(peerId)) + _args.add(Variant(method)) + varargs.forEach { _args.add(Variant.fromAny(it)) } + val _ret = __method_bind.rpcUnreliableId.slowcall(this._handle, _args) + return _ret } fun rset(property: String, value: Variant) { diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Object.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Object.kt index e5df3617..69270510 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Object.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Object.kt @@ -86,27 +86,18 @@ open class Object( } fun call(method: String, vararg varargs: Any?): Variant { - val self = this - return Allocator.allocationScope { - val _ret = Variant() - val _retPtr = _ret._value.ptr - val _args = mutableListOf() - _args.add(method) - varargs.forEach { _args.add(it) } - __method_bind.call.call(self._handle, _args, _retPtr) - _ret._value = _retPtr.pointed.readValue() - _ret - } + val _args = mutableListOf() + _args.add(Variant(method)) + varargs.forEach { _args.add(Variant.fromAny(it)) } + val _ret = __method_bind.call.slowcall(this._handle, _args) + return _ret } fun callDeferred(method: String, vararg varargs: Any?) { - val self = this - return Allocator.allocationScope { - val _args = mutableListOf() - _args.add(method) - varargs.forEach { _args.add(it) } - __method_bind.callDeferred.call(self._handle, _args, null) - } + val _args = mutableListOf() + _args.add(Variant(method)) + varargs.forEach { _args.add(Variant.fromAny(it)) } + val _ret = __method_bind.callDeferred.slowcall(this._handle, _args) } fun callv(method: String, argArray: VariantArray): Variant { @@ -171,13 +162,10 @@ open class Object( } fun emitSignal(signal: String, vararg varargs: Any?) { - val self = this - return Allocator.allocationScope { - val _args = mutableListOf() - _args.add(signal) - varargs.forEach { _args.add(it) } - __method_bind.emitSignal.call(self._handle, _args, null) - } + val _args = mutableListOf() + _args.add(Variant(signal)) + varargs.forEach { _args.add(Variant.fromAny(it)) } + val _ret = __method_bind.emitSignal.slowcall(this._handle, _args) } fun free() { diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PluginScript.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PluginScript.kt index 6f5fe09c..e9ae9918 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PluginScript.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PluginScript.kt @@ -38,16 +38,10 @@ open class PluginScript( } fun new(vararg varargs: Any?): Variant { - val self = this - return Allocator.allocationScope { - val _ret = Variant() - val _retPtr = _ret._value.ptr - val _args = mutableListOf() - varargs.forEach { _args.add(it) } - __method_bind.new.call(self._handle, _args, _retPtr) - _ret._value = _retPtr.pointed.readValue() - _ret - } + val _args = mutableListOf() + varargs.forEach { _args.add(Variant.fromAny(it)) } + val _ret = __method_bind.new.slowcall(this._handle, _args) + return _ret } companion object { diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/SceneTree.kt b/godot-kotlin/src/nativeGen/kotlin/godot/SceneTree.kt index cd48519e..f56e07a6 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/SceneTree.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/SceneTree.kt @@ -234,18 +234,12 @@ open class SceneTree( method: String, vararg varargs: Any? ): godot.core.Variant { - val self = this - return Allocator.allocationScope { - val _ret = godot.core.Variant() - val _retPtr = _ret._value.ptr - val _args = mutableListOf() - _args.add(group) - _args.add(method) - varargs.forEach { _args.add(it) } - __method_bind.callGroup.call(self._handle, _args, _retPtr) - _ret._value = _retPtr.pointed.readValue() - _ret - } + val _args = mutableListOf() + _args.add(Variant(group)) + _args.add(Variant(method)) + varargs.forEach { _args.add(Variant.fromAny(it)) } + val _ret = __method_bind.callGroup.slowcall(this._handle, _args) + return _ret } fun callGroupFlags( @@ -254,19 +248,13 @@ open class SceneTree( method: String, vararg varargs: Any? ): godot.core.Variant { - val self = this - return Allocator.allocationScope { - val _ret = godot.core.Variant() - val _retPtr = _ret._value.ptr - val _args = mutableListOf() - _args.add(flags) - _args.add(group) - _args.add(method) - varargs.forEach { _args.add(it) } - __method_bind.callGroupFlags.call(self._handle, _args, _retPtr) - _ret._value = _retPtr.pointed.readValue() - _ret - } + val _args = mutableListOf() + _args.add(Variant(flags)) + _args.add(Variant(group)) + _args.add(Variant(method)) + varargs.forEach { _args.add(Variant.fromAny(it)) } + val _ret = __method_bind.callGroupFlags.slowcall(this._handle, _args) + return _ret } fun changeScene(path: String): GDError { diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/TreeItem.kt b/godot-kotlin/src/nativeGen/kotlin/godot/TreeItem.kt index bb91491b..9fd5d849 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/TreeItem.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/TreeItem.kt @@ -87,17 +87,11 @@ open class TreeItem( } fun callRecursive(method: String, vararg varargs: Any?): Variant { - val self = this - return Allocator.allocationScope { - val _ret = Variant() - val _retPtr = _ret._value.ptr - val _args = mutableListOf() - _args.add(method) - varargs.forEach { _args.add(it) } - __method_bind.callRecursive.call(self._handle, _args, _retPtr) - _ret._value = _retPtr.pointed.readValue() - _ret - } + val _args = mutableListOf() + _args.add(Variant(method)) + varargs.forEach { _args.add(Variant.fromAny(it)) } + val _ret = __method_bind.callRecursive.slowcall(this._handle, _args) + return _ret } fun clearCustomBgColor(column: Int) { diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/UndoRedo.kt b/godot-kotlin/src/nativeGen/kotlin/godot/UndoRedo.kt index 8a05f60a..3659fbcf 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/UndoRedo.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/UndoRedo.kt @@ -49,14 +49,11 @@ open class UndoRedo( method: String, vararg varargs: Any? ) { - val self = this - return Allocator.allocationScope { - val _args = mutableListOf() - _args.add(`object`) - _args.add(method) - varargs.forEach { _args.add(it) } - __method_bind.addDoMethod.call(self._handle, _args, null) - } + val _args = mutableListOf() + _args.add(Variant(`object`)) + _args.add(Variant(method)) + varargs.forEach { _args.add(Variant.fromAny(it)) } + val _ret = __method_bind.addDoMethod.slowcall(this._handle, _args) } fun addDoProperty( @@ -86,14 +83,11 @@ open class UndoRedo( method: String, vararg varargs: Any? ) { - val self = this - return Allocator.allocationScope { - val _args = mutableListOf() - _args.add(`object`) - _args.add(method) - varargs.forEach { _args.add(it) } - __method_bind.addUndoMethod.call(self._handle, _args, null) - } + val _args = mutableListOf() + _args.add(Variant(`object`)) + _args.add(Variant(method)) + varargs.forEach { _args.add(Variant.fromAny(it)) } + val _ret = __method_bind.addUndoMethod.slowcall(this._handle, _args) } fun addUndoProperty( diff --git a/godot-kotlin/src/nativeMain/kotlin/godot/methodBindUtils.kt b/godot-kotlin/src/nativeMain/kotlin/godot/methodBindUtils.kt index a61429c5..554627f8 100644 --- a/godot-kotlin/src/nativeMain/kotlin/godot/methodBindUtils.kt +++ b/godot-kotlin/src/nativeMain/kotlin/godot/methodBindUtils.kt @@ -48,4 +48,43 @@ fun CPointer.call(instance: COpaquePointer, args: List, checkNotNull(Godot.gdnative.godot_string_destroy)(str.ptr) } } +} + +fun CPointer.slowcall(instance: COpaquePointer, args: List): Variant { + return Allocator.allocationScope { + val error = alloc() + val ptr = allocArrayOf(args.map { it._value.ptr }) + val ret = checkNotNull(Godot.gdnative.godot_method_bind_call)( + this@slowcall, + instance, + ptr, + args.count(), + error.ptr + ) + + maybeThrowException(error) + + Variant(ret) + } +} + +private fun maybeThrowException(error: godot_variant_call_error) { + when (error.error) { + godot_variant_call_error_error.GODOT_CALL_ERROR_CALL_OK -> {} + godot_variant_call_error_error.GODOT_CALL_ERROR_CALL_ERROR_INSTANCE_IS_NULL -> { + throw NullPointerException("Can not call invoke to a null instance!") + } + godot_variant_call_error_error.GODOT_CALL_ERROR_CALL_ERROR_INVALID_ARGUMENT -> { + throw IllegalArgumentException( + "Invalid argument at position ${error.argument}, expecting a ${Variant.Type.from(error.expected.value.toInt())}" + ) + } + godot_variant_call_error_error.GODOT_CALL_ERROR_CALL_ERROR_INVALID_METHOD -> { + throw IllegalArgumentException("Invalid method!") + } + godot_variant_call_error_error.GODOT_CALL_ERROR_CALL_ERROR_TOO_FEW_ARGUMENTS, + godot_variant_call_error_error.GODOT_CALL_ERROR_CALL_ERROR_TOO_MANY_ARGUMENTS -> { + throw IllegalArgumentException("Invalid number of arguments passed to method, expecting ${error.argument}") + } + } } \ No newline at end of file From c878d7926d0539f05c2e689ff25ac24b9e4ee98d Mon Sep 17 00:00:00 2001 From: Ranie Jade Ramiso Date: Sat, 7 Mar 2020 12:00:26 +1100 Subject: [PATCH 2/2] Add Bunnymark bench mark --- .../main/kotlin/godot/codegen/APIGenerator.kt | 19 +- .../src/nativeGen/kotlin/godot/ARVRAnchor.kt | 105 +- .../nativeGen/kotlin/godot/ARVRController.kt | 176 +- .../nativeGen/kotlin/godot/ARVRInterface.kt | 226 +- .../src/nativeGen/kotlin/godot/ARVROrigin.kt | 30 +- .../kotlin/godot/ARVRPositionalTracker.kt | 192 +- .../src/nativeGen/kotlin/godot/ARVRServer.kt | 240 +- .../src/nativeGen/kotlin/godot/AStar.kt | 323 +- .../src/nativeGen/kotlin/godot/AStar2D.kt | 346 +- .../nativeGen/kotlin/godot/AcceptDialog.kt | 176 +- .../nativeGen/kotlin/godot/AnimatedSprite.kt | 304 +- .../kotlin/godot/AnimatedSprite3D.kt | 144 +- .../nativeGen/kotlin/godot/AnimatedTexture.kt | 128 +- .../src/nativeGen/kotlin/godot/Animation.kt | 968 +-- .../nativeGen/kotlin/godot/AnimationNode.kt | 208 +- .../kotlin/godot/AnimationNodeAdd2.kt | 32 +- .../kotlin/godot/AnimationNodeAdd3.kt | 32 +- .../kotlin/godot/AnimationNodeAnimation.kt | 32 +- .../kotlin/godot/AnimationNodeBlend2.kt | 32 +- .../kotlin/godot/AnimationNodeBlend3.kt | 32 +- .../kotlin/godot/AnimationNodeBlendSpace1D.kt | 240 +- .../kotlin/godot/AnimationNodeBlendSpace2D.kt | 400 +- .../kotlin/godot/AnimationNodeBlendTree.kt | 176 +- .../kotlin/godot/AnimationNodeOneShot.kt | 224 +- .../kotlin/godot/AnimationNodeStateMachine.kt | 352 +- .../AnimationNodeStateMachinePlayback.kt | 96 +- .../AnimationNodeStateMachineTransition.kt | 192 +- .../kotlin/godot/AnimationNodeTransition.kt | 128 +- .../nativeGen/kotlin/godot/AnimationPlayer.kt | 673 +- .../nativeGen/kotlin/godot/AnimationTree.kt | 208 +- .../kotlin/godot/AnimationTreePlayer.kt | 1059 +-- .../src/nativeGen/kotlin/godot/Area.kt | 616 +- .../src/nativeGen/kotlin/godot/Area2D.kt | 504 +- .../src/nativeGen/kotlin/godot/ArrayMesh.kt | 300 +- .../nativeGen/kotlin/godot/AtlasTexture.kt | 128 +- .../kotlin/godot/AudioEffectAmplify.kt | 32 +- .../kotlin/godot/AudioEffectChorus.kt | 288 +- .../kotlin/godot/AudioEffectCompressor.kt | 224 +- .../kotlin/godot/AudioEffectDelay.kt | 416 +- .../kotlin/godot/AudioEffectDistortion.kt | 160 +- .../nativeGen/kotlin/godot/AudioEffectEQ.kt | 48 +- .../kotlin/godot/AudioEffectFilter.kt | 128 +- .../kotlin/godot/AudioEffectLimiter.kt | 128 +- .../kotlin/godot/AudioEffectPanner.kt | 32 +- .../kotlin/godot/AudioEffectPhaser.kt | 160 +- .../kotlin/godot/AudioEffectPitchShift.kt | 96 +- .../kotlin/godot/AudioEffectRecord.kt | 80 +- .../kotlin/godot/AudioEffectReverb.kt | 256 +- .../godot/AudioEffectSpectrumAnalyzer.kt | 96 +- .../AudioEffectSpectrumAnalyzerInstance.kt | 16 +- .../kotlin/godot/AudioEffectStereoEnhance.kt | 96 +- .../src/nativeGen/kotlin/godot/AudioServer.kt | 736 +- .../src/nativeGen/kotlin/godot/AudioStream.kt | 16 +- .../kotlin/godot/AudioStreamGenerator.kt | 64 +- .../godot/AudioStreamGeneratorPlayback.kt | 96 +- .../kotlin/godot/AudioStreamOGGVorbis.kt | 96 +- .../kotlin/godot/AudioStreamPlayer.kt | 320 +- .../kotlin/godot/AudioStreamPlayer2D.kt | 384 +- .../kotlin/godot/AudioStreamPlayer3D.kt | 678 +- .../kotlin/godot/AudioStreamRandomPitch.kt | 64 +- .../kotlin/godot/AudioStreamSample.kt | 240 +- .../nativeGen/kotlin/godot/BackBufferCopy.kt | 64 +- .../nativeGen/kotlin/godot/BakedLightmap.kt | 386 +- .../kotlin/godot/BakedLightmapData.kt | 240 +- .../src/nativeGen/kotlin/godot/BaseButton.kt | 331 +- .../src/nativeGen/kotlin/godot/BitMap.kt | 126 +- .../src/nativeGen/kotlin/godot/BitmapFont.kt | 210 +- .../src/nativeGen/kotlin/godot/Bone2D.kt | 98 +- .../nativeGen/kotlin/godot/BoneAttachment.kt | 32 +- .../nativeGen/kotlin/godot/BoxContainer.kt | 48 +- .../src/nativeGen/kotlin/godot/BoxShape.kt | 30 +- .../src/nativeGen/kotlin/godot/Button.kt | 168 +- .../src/nativeGen/kotlin/godot/ButtonGroup.kt | 32 +- .../nativeGen/kotlin/godot/CPUParticles.kt | 992 +-- .../nativeGen/kotlin/godot/CPUParticles2D.kt | 992 +-- .../src/nativeGen/kotlin/godot/CSGBox.kt | 112 +- .../src/nativeGen/kotlin/godot/CSGCylinder.kt | 192 +- .../src/nativeGen/kotlin/godot/CSGMesh.kt | 60 +- .../src/nativeGen/kotlin/godot/CSGPolygon.kt | 390 +- .../nativeGen/kotlin/godot/CSGPrimitive.kt | 32 +- .../src/nativeGen/kotlin/godot/CSGShape.kt | 270 +- .../src/nativeGen/kotlin/godot/CSGSphere.kt | 150 +- .../src/nativeGen/kotlin/godot/CSGTorus.kt | 180 +- .../src/nativeGen/kotlin/godot/Camera.kt | 588 +- .../src/nativeGen/kotlin/godot/Camera2D.kt | 660 +- .../src/nativeGen/kotlin/godot/CameraFeed.kt | 105 +- .../nativeGen/kotlin/godot/CameraServer.kt | 80 +- .../nativeGen/kotlin/godot/CameraTexture.kt | 96 +- .../src/nativeGen/kotlin/godot/CanvasItem.kt | 889 ++- .../kotlin/godot/CanvasItemMaterial.kt | 192 +- .../src/nativeGen/kotlin/godot/CanvasLayer.kt | 304 +- .../nativeGen/kotlin/godot/CanvasModulate.kt | 32 +- .../src/nativeGen/kotlin/godot/CapsuleMesh.kt | 128 +- .../nativeGen/kotlin/godot/CapsuleShape.kt | 64 +- .../nativeGen/kotlin/godot/CapsuleShape2D.kt | 64 +- .../nativeGen/kotlin/godot/CenterContainer.kt | 32 +- .../nativeGen/kotlin/godot/CharFXTransform.kt | 256 +- .../nativeGen/kotlin/godot/CircleShape2D.kt | 32 +- .../src/nativeGen/kotlin/godot/ClassDB.kt | 301 +- .../nativeGen/kotlin/godot/ClippedCamera.kt | 288 +- .../nativeGen/kotlin/godot/CollisionObject.kt | 320 +- .../kotlin/godot/CollisionObject2D.kt | 358 +- .../kotlin/godot/CollisionPolygon.kt | 96 +- .../kotlin/godot/CollisionPolygon2D.kt | 160 +- .../nativeGen/kotlin/godot/CollisionShape.kt | 96 +- .../kotlin/godot/CollisionShape2D.kt | 128 +- .../src/nativeGen/kotlin/godot/ColorPicker.kt | 272 +- .../kotlin/godot/ColorPickerButton.kt | 96 +- .../src/nativeGen/kotlin/godot/ColorRect.kt | 30 +- .../kotlin/godot/ConcavePolygonShape.kt | 32 +- .../kotlin/godot/ConcavePolygonShape2D.kt | 32 +- .../nativeGen/kotlin/godot/ConeTwistJoint.kt | 32 +- .../src/nativeGen/kotlin/godot/ConfigFile.kt | 210 +- .../kotlin/godot/ConfirmationDialog.kt | 16 +- .../src/nativeGen/kotlin/godot/Container.kt | 30 +- .../src/nativeGen/kotlin/godot/Control.kt | 1456 ++-- .../kotlin/godot/ConvexPolygonShape.kt | 32 +- .../kotlin/godot/ConvexPolygonShape2D.kt | 48 +- .../src/nativeGen/kotlin/godot/Crypto.kt | 43 +- .../src/nativeGen/kotlin/godot/CryptoKey.kt | 30 +- .../src/nativeGen/kotlin/godot/CubeMap.kt | 150 +- .../src/nativeGen/kotlin/godot/CubeMesh.kt | 120 +- .../src/nativeGen/kotlin/godot/Curve.kt | 350 +- .../src/nativeGen/kotlin/godot/Curve2D.kt | 300 +- .../src/nativeGen/kotlin/godot/Curve3D.kt | 405 +- .../nativeGen/kotlin/godot/CurveTexture.kt | 48 +- .../nativeGen/kotlin/godot/CylinderMesh.kt | 160 +- .../nativeGen/kotlin/godot/CylinderShape.kt | 64 +- .../kotlin/godot/DampedSpringJoint2D.kt | 128 +- .../kotlin/godot/DirectionalLight.kt | 96 +- .../src/nativeGen/kotlin/godot/Directory.kt | 270 +- .../src/nativeGen/kotlin/godot/DynamicFont.kt | 304 +- .../nativeGen/kotlin/godot/DynamicFontData.kt | 96 +- .../kotlin/godot/EditorExportPlugin.kt | 128 +- .../kotlin/godot/EditorFeatureProfile.kt | 176 +- .../kotlin/godot/EditorFileDialog.kt | 322 +- .../kotlin/godot/EditorFileSystem.kt | 144 +- .../kotlin/godot/EditorFileSystemDirectory.kt | 225 +- .../nativeGen/kotlin/godot/EditorInspector.kt | 16 +- .../kotlin/godot/EditorInspectorPlugin.kt | 50 +- .../nativeGen/kotlin/godot/EditorInterface.kt | 384 +- .../godot/EditorNavigationMeshGenerator.kt | 32 +- .../nativeGen/kotlin/godot/EditorPlugin.kt | 519 +- .../nativeGen/kotlin/godot/EditorProperty.kt | 288 +- .../kotlin/godot/EditorResourcePreview.kt | 81 +- .../kotlin/godot/EditorSceneImporter.kt | 35 +- .../kotlin/godot/EditorScenePostImport.kt | 32 +- .../nativeGen/kotlin/godot/EditorScript.kt | 48 +- .../nativeGen/kotlin/godot/EditorSelection.kt | 81 +- .../nativeGen/kotlin/godot/EditorSettings.kt | 256 +- .../kotlin/godot/EditorSpatialGizmo.kt | 176 +- .../kotlin/godot/EditorSpatialGizmoPlugin.kt | 80 +- .../kotlin/godot/EditorSpinSlider.kt | 96 +- .../kotlin/godot/EditorVCSInterface.kt | 176 +- .../kotlin/godot/EncodedObjectAsID.kt | 32 +- .../src/nativeGen/kotlin/godot/Engine.kt | 375 +- .../src/nativeGen/kotlin/godot/Environment.kt | 2507 ++++--- .../src/nativeGen/kotlin/godot/Expression.kt | 60 +- .../src/nativeGen/kotlin/godot/File.kt | 644 +- .../src/nativeGen/kotlin/godot/FileDialog.kt | 330 +- .../src/nativeGen/kotlin/godot/Font.kt | 140 +- .../src/nativeGen/kotlin/godot/FuncRef.kt | 75 +- .../src/nativeGen/kotlin/godot/GDNative.kt | 75 +- .../nativeGen/kotlin/godot/GDNativeLibrary.kt | 192 +- .../src/nativeGen/kotlin/godot/GDScript.kt | 30 +- .../kotlin/godot/GDScriptFunctionState.kt | 32 +- .../src/nativeGen/kotlin/godot/GIProbe.kt | 330 +- .../src/nativeGen/kotlin/godot/GIProbeData.kt | 352 +- .../kotlin/godot/Generic6DOFJoint.kt | 224 +- .../src/nativeGen/kotlin/godot/Geometry.kt | 536 +- .../kotlin/godot/GeometryInstance.kt | 272 +- .../src/nativeGen/kotlin/godot/Gradient.kt | 180 +- .../nativeGen/kotlin/godot/GradientTexture.kt | 48 +- .../src/nativeGen/kotlin/godot/GraphEdit.kt | 377 +- .../src/nativeGen/kotlin/godot/GraphNode.kt | 467 +- .../nativeGen/kotlin/godot/GridContainer.kt | 32 +- .../src/nativeGen/kotlin/godot/GridMap.kt | 540 +- .../nativeGen/kotlin/godot/GrooveJoint2D.kt | 64 +- .../src/nativeGen/kotlin/godot/HTTPClient.kt | 300 +- .../src/nativeGen/kotlin/godot/HTTPRequest.kt | 272 +- .../nativeGen/kotlin/godot/HashingContext.kt | 48 +- .../nativeGen/kotlin/godot/HeightMapShape.kt | 96 +- .../src/nativeGen/kotlin/godot/HingeJoint.kt | 60 +- godot-kotlin/src/nativeGen/kotlin/godot/IP.kt | 112 +- .../src/nativeGen/kotlin/godot/Image.kt | 714 +- .../nativeGen/kotlin/godot/ImageTexture.kt | 160 +- .../kotlin/godot/ImmediateGeometry.kt | 160 +- .../src/nativeGen/kotlin/godot/Input.kt | 562 +- .../src/nativeGen/kotlin/godot/InputEvent.kt | 195 +- .../kotlin/godot/InputEventAction.kt | 80 +- .../kotlin/godot/InputEventGesture.kt | 32 +- .../kotlin/godot/InputEventJoypadButton.kt | 80 +- .../kotlin/godot/InputEventJoypadMotion.kt | 64 +- .../nativeGen/kotlin/godot/InputEventKey.kt | 112 +- .../nativeGen/kotlin/godot/InputEventMIDI.kt | 256 +- .../kotlin/godot/InputEventMagnifyGesture.kt | 32 +- .../nativeGen/kotlin/godot/InputEventMouse.kt | 96 +- .../kotlin/godot/InputEventMouseButton.kt | 112 +- .../kotlin/godot/InputEventMouseMotion.kt | 128 +- .../kotlin/godot/InputEventPanGesture.kt | 32 +- .../kotlin/godot/InputEventScreenDrag.kt | 128 +- .../kotlin/godot/InputEventScreenTouch.kt | 80 +- .../kotlin/godot/InputEventWithModifiers.kt | 160 +- .../src/nativeGen/kotlin/godot/InputMap.kt | 180 +- .../kotlin/godot/InstancePlaceholder.kt | 64 +- .../kotlin/godot/InterpolatedCamera.kt | 112 +- .../src/nativeGen/kotlin/godot/ItemList.kt | 930 ++- .../src/nativeGen/kotlin/godot/JSON.kt | 28 +- .../nativeGen/kotlin/godot/JSONParseResult.kt | 128 +- .../src/nativeGen/kotlin/godot/JSONRPC.kt | 105 +- .../kotlin/godot/JavaClassWrapper.kt | 16 +- .../src/nativeGen/kotlin/godot/JavaScript.kt | 15 +- .../src/nativeGen/kotlin/godot/Joint.kt | 114 +- .../src/nativeGen/kotlin/godot/Joint2D.kt | 122 +- .../nativeGen/kotlin/godot/KinematicBody.kt | 240 +- .../nativeGen/kotlin/godot/KinematicBody2D.kt | 240 +- .../kotlin/godot/KinematicCollision.kt | 176 +- .../kotlin/godot/KinematicCollision2D.kt | 176 +- .../src/nativeGen/kotlin/godot/Label.kt | 336 +- .../nativeGen/kotlin/godot/LargeTexture.kt | 128 +- .../src/nativeGen/kotlin/godot/Light.kt | 252 +- .../src/nativeGen/kotlin/godot/Light2D.kt | 630 +- .../nativeGen/kotlin/godot/LightOccluder2D.kt | 64 +- .../src/nativeGen/kotlin/godot/Line2D.kt | 448 +- .../src/nativeGen/kotlin/godot/LineEdit.kt | 615 +- .../src/nativeGen/kotlin/godot/LineShape2D.kt | 64 +- .../src/nativeGen/kotlin/godot/LinkButton.kt | 60 +- .../src/nativeGen/kotlin/godot/Listener.kt | 60 +- .../src/nativeGen/kotlin/godot/MainLoop.kt | 90 +- .../src/nativeGen/kotlin/godot/Marshalls.kt | 90 +- .../src/nativeGen/kotlin/godot/Material.kt | 60 +- .../src/nativeGen/kotlin/godot/MenuButton.kt | 60 +- .../src/nativeGen/kotlin/godot/Mesh.kt | 183 +- .../nativeGen/kotlin/godot/MeshDataTool.kt | 608 +- .../nativeGen/kotlin/godot/MeshInstance.kt | 192 +- .../nativeGen/kotlin/godot/MeshInstance2D.kt | 96 +- .../src/nativeGen/kotlin/godot/MeshLibrary.kt | 288 +- .../src/nativeGen/kotlin/godot/MeshTexture.kt | 96 +- .../kotlin/godot/MobileVRInterface.kt | 224 +- .../src/nativeGen/kotlin/godot/MultiMesh.kt | 330 +- .../kotlin/godot/MultiMeshInstance.kt | 32 +- .../kotlin/godot/MultiMeshInstance2D.kt | 96 +- .../nativeGen/kotlin/godot/MultiplayerAPI.kt | 242 +- .../src/nativeGen/kotlin/godot/Mutex.kt | 42 +- .../nativeGen/kotlin/godot/NativeScript.kt | 208 +- .../src/nativeGen/kotlin/godot/Navigation.kt | 150 +- .../nativeGen/kotlin/godot/Navigation2D.kt | 96 +- .../nativeGen/kotlin/godot/NavigationMesh.kt | 822 ++- .../kotlin/godot/NavigationMeshInstance.kt | 64 +- .../kotlin/godot/NavigationPolygon.kt | 224 +- .../kotlin/godot/NavigationPolygonInstance.kt | 64 +- .../kotlin/godot/NetworkedMultiplayerENet.kt | 304 +- .../kotlin/godot/NetworkedMultiplayerPeer.kt | 144 +- .../nativeGen/kotlin/godot/NinePatchRect.kt | 192 +- .../src/nativeGen/kotlin/godot/Node.kt | 1226 ++-- .../src/nativeGen/kotlin/godot/Node2D.kt | 463 +- .../nativeGen/kotlin/godot/NoiseTexture.kt | 160 +- godot-kotlin/src/nativeGen/kotlin/godot/OS.kt | 1928 +++--- .../src/nativeGen/kotlin/godot/Object.kt | 560 +- .../kotlin/godot/OccluderPolygon2D.kt | 96 +- .../src/nativeGen/kotlin/godot/OmniLight.kt | 60 +- .../kotlin/godot/OpenSimplexNoise.kt | 288 +- .../nativeGen/kotlin/godot/OptionButton.kt | 352 +- .../src/nativeGen/kotlin/godot/PCKPacker.kt | 45 +- .../kotlin/godot/PHashTranslation.kt | 16 +- .../kotlin/godot/PackedDataContainer.kt | 32 +- .../kotlin/godot/PackedDataContainerRef.kt | 16 +- .../src/nativeGen/kotlin/godot/PackedScene.kt | 64 +- .../src/nativeGen/kotlin/godot/PacketPeer.kt | 150 +- .../kotlin/godot/PacketPeerStream.kt | 96 +- .../nativeGen/kotlin/godot/PacketPeerUDP.kt | 160 +- .../src/nativeGen/kotlin/godot/PanoramaSky.kt | 32 +- .../kotlin/godot/ParallaxBackground.kt | 192 +- .../nativeGen/kotlin/godot/ParallaxLayer.kt | 96 +- .../src/nativeGen/kotlin/godot/Particles.kt | 510 +- .../src/nativeGen/kotlin/godot/Particles2D.kt | 544 +- .../kotlin/godot/ParticlesMaterial.kt | 672 +- .../src/nativeGen/kotlin/godot/Path.kt | 28 +- .../src/nativeGen/kotlin/godot/Path2D.kt | 28 +- .../src/nativeGen/kotlin/godot/PathFollow.kt | 210 +- .../nativeGen/kotlin/godot/PathFollow2D.kt | 256 +- .../src/nativeGen/kotlin/godot/Performance.kt | 16 +- .../nativeGen/kotlin/godot/PhysicalBone.kt | 352 +- .../kotlin/godot/Physics2DDirectBodyState.kt | 533 +- .../kotlin/godot/Physics2DDirectSpaceState.kt | 112 +- .../nativeGen/kotlin/godot/Physics2DServer.kt | 1651 +++-- .../godot/Physics2DShapeQueryParameters.kt | 274 +- .../kotlin/godot/Physics2DShapeQueryResult.kt | 80 +- .../kotlin/godot/Physics2DTestMotionResult.kt | 144 +- .../src/nativeGen/kotlin/godot/PhysicsBody.kt | 177 +- .../nativeGen/kotlin/godot/PhysicsBody2D.kt | 177 +- .../kotlin/godot/PhysicsDirectBodyState.kt | 563 +- .../kotlin/godot/PhysicsDirectSpaceState.kt | 80 +- .../nativeGen/kotlin/godot/PhysicsMaterial.kt | 128 +- .../nativeGen/kotlin/godot/PhysicsServer.kt | 1823 ++--- .../godot/PhysicsShapeQueryParameters.kt | 242 +- .../kotlin/godot/PhysicsShapeQueryResult.kt | 80 +- .../src/nativeGen/kotlin/godot/PinJoint.kt | 30 +- .../src/nativeGen/kotlin/godot/PinJoint2D.kt | 30 +- .../src/nativeGen/kotlin/godot/PlaneMesh.kt | 90 +- .../src/nativeGen/kotlin/godot/PlaneShape.kt | 30 +- .../nativeGen/kotlin/godot/PluginScript.kt | 16 +- .../src/nativeGen/kotlin/godot/Polygon2D.kt | 600 +- .../kotlin/godot/PolygonPathFinder.kt | 128 +- .../src/nativeGen/kotlin/godot/Popup.kt | 112 +- .../src/nativeGen/kotlin/godot/PopupMenu.kt | 938 +-- .../nativeGen/kotlin/godot/PrimitiveMesh.kt | 112 +- .../src/nativeGen/kotlin/godot/PrismMesh.kt | 150 +- .../nativeGen/kotlin/godot/ProceduralSky.kt | 512 +- .../src/nativeGen/kotlin/godot/ProgressBar.kt | 32 +- .../nativeGen/kotlin/godot/ProjectSettings.kt | 240 +- .../nativeGen/kotlin/godot/ProximityGroup.kt | 112 +- .../nativeGen/kotlin/godot/ProxyTexture.kt | 32 +- .../src/nativeGen/kotlin/godot/QuadMesh.kt | 30 +- .../kotlin/godot/RandomNumberGenerator.kt | 128 +- .../src/nativeGen/kotlin/godot/Range.kt | 308 +- .../src/nativeGen/kotlin/godot/RayCast.kt | 377 +- .../src/nativeGen/kotlin/godot/RayCast2D.kt | 377 +- .../src/nativeGen/kotlin/godot/RayShape.kt | 60 +- .../src/nativeGen/kotlin/godot/RayShape2D.kt | 60 +- .../kotlin/godot/RectangleShape2D.kt | 32 +- .../src/nativeGen/kotlin/godot/Reference.kt | 45 +- .../nativeGen/kotlin/godot/ReferenceRect.kt | 64 +- .../nativeGen/kotlin/godot/ReflectionProbe.kt | 388 +- .../src/nativeGen/kotlin/godot/RegEx.kt | 126 +- .../src/nativeGen/kotlin/godot/RegExMatch.kt | 105 +- .../nativeGen/kotlin/godot/RemoteTransform.kt | 176 +- .../kotlin/godot/RemoteTransform2D.kt | 176 +- .../src/nativeGen/kotlin/godot/Resource.kt | 165 +- .../kotlin/godot/ResourceInteractiveLoader.kt | 80 +- .../nativeGen/kotlin/godot/ResourceLoader.kt | 129 +- .../kotlin/godot/ResourcePreloader.kt | 96 +- .../nativeGen/kotlin/godot/ResourceSaver.kt | 32 +- .../nativeGen/kotlin/godot/RichTextLabel.kt | 897 +-- .../src/nativeGen/kotlin/godot/RigidBody.kt | 666 +- .../src/nativeGen/kotlin/godot/RigidBody2D.kt | 790 ++- .../src/nativeGen/kotlin/godot/SceneState.kt | 301 +- .../src/nativeGen/kotlin/godot/SceneTree.kt | 707 +- .../nativeGen/kotlin/godot/SceneTreeTimer.kt | 32 +- .../src/nativeGen/kotlin/godot/Script.kt | 210 +- .../kotlin/godot/ScriptCreateDialog.kt | 16 +- .../nativeGen/kotlin/godot/ScriptEditor.kt | 112 +- .../src/nativeGen/kotlin/godot/ScrollBar.kt | 30 +- .../nativeGen/kotlin/godot/ScrollContainer.kt | 224 +- .../nativeGen/kotlin/godot/SegmentShape2D.kt | 64 +- .../src/nativeGen/kotlin/godot/Semaphore.kt | 30 +- .../src/nativeGen/kotlin/godot/Shader.kt | 84 +- .../nativeGen/kotlin/godot/ShaderMaterial.kt | 96 +- .../src/nativeGen/kotlin/godot/Shape.kt | 28 +- .../src/nativeGen/kotlin/godot/Shape2D.kt | 92 +- .../src/nativeGen/kotlin/godot/ShortCut.kt | 75 +- .../src/nativeGen/kotlin/godot/Skeleton.kt | 413 +- .../src/nativeGen/kotlin/godot/Skeleton2D.kt | 45 +- .../src/nativeGen/kotlin/godot/SkeletonIK.kt | 360 +- .../src/nativeGen/kotlin/godot/Skin.kt | 112 +- .../nativeGen/kotlin/godot/SkinReference.kt | 32 +- .../src/nativeGen/kotlin/godot/Sky.kt | 28 +- .../src/nativeGen/kotlin/godot/Slider.kt | 112 +- .../src/nativeGen/kotlin/godot/SliderJoint.kt | 32 +- .../src/nativeGen/kotlin/godot/SoftBody.kt | 498 +- .../src/nativeGen/kotlin/godot/Spatial.kt | 741 +- .../nativeGen/kotlin/godot/SpatialMaterial.kt | 1843 ++--- .../kotlin/godot/SpatialVelocityTracker.kt | 80 +- .../src/nativeGen/kotlin/godot/SphereMesh.kt | 150 +- .../src/nativeGen/kotlin/godot/SphereShape.kt | 32 +- .../src/nativeGen/kotlin/godot/SpinBox.kt | 150 +- .../nativeGen/kotlin/godot/SplitContainer.kt | 112 +- .../src/nativeGen/kotlin/godot/SpringArm.kt | 180 +- .../src/nativeGen/kotlin/godot/Sprite.kt | 393 +- .../src/nativeGen/kotlin/godot/Sprite3D.kt | 210 +- .../nativeGen/kotlin/godot/SpriteBase3D.kt | 384 +- .../nativeGen/kotlin/godot/SpriteFrames.kt | 256 +- .../src/nativeGen/kotlin/godot/StaticBody.kt | 154 +- .../nativeGen/kotlin/godot/StaticBody2D.kt | 164 +- .../src/nativeGen/kotlin/godot/StreamPeer.kt | 495 +- .../kotlin/godot/StreamPeerBuffer.kt | 128 +- .../nativeGen/kotlin/godot/StreamPeerSSL.kt | 114 +- .../nativeGen/kotlin/godot/StreamPeerTCP.kt | 112 +- .../nativeGen/kotlin/godot/StreamTexture.kt | 32 +- .../src/nativeGen/kotlin/godot/StyleBox.kt | 135 +- .../nativeGen/kotlin/godot/StyleBoxFlat.kt | 512 +- .../nativeGen/kotlin/godot/StyleBoxLine.kt | 160 +- .../nativeGen/kotlin/godot/StyleBoxTexture.kt | 320 +- .../src/nativeGen/kotlin/godot/SurfaceTool.kt | 368 +- .../src/nativeGen/kotlin/godot/TCP_Server.kt | 75 +- .../nativeGen/kotlin/godot/TabContainer.kt | 388 +- .../src/nativeGen/kotlin/godot/Tabs.kt | 394 +- .../src/nativeGen/kotlin/godot/TextEdit.kt | 1430 ++-- .../src/nativeGen/kotlin/godot/Texture.kt | 150 +- .../nativeGen/kotlin/godot/TextureButton.kt | 256 +- .../nativeGen/kotlin/godot/TextureLayered.kt | 160 +- .../nativeGen/kotlin/godot/TextureProgress.kt | 384 +- .../src/nativeGen/kotlin/godot/TextureRect.kt | 160 +- .../src/nativeGen/kotlin/godot/Theme.kt | 448 +- .../src/nativeGen/kotlin/godot/Thread.kt | 60 +- .../src/nativeGen/kotlin/godot/TileMap.kt | 871 ++- .../src/nativeGen/kotlin/godot/TileSet.kt | 981 +-- .../src/nativeGen/kotlin/godot/Timer.kt | 196 +- .../kotlin/godot/TouchScreenButton.kt | 304 +- .../src/nativeGen/kotlin/godot/Translation.kt | 112 +- .../kotlin/godot/TranslationServer.kt | 128 +- .../src/nativeGen/kotlin/godot/Tree.kt | 518 +- .../src/nativeGen/kotlin/godot/TreeItem.kt | 990 +-- .../src/nativeGen/kotlin/godot/Tween.kt | 393 +- .../src/nativeGen/kotlin/godot/UPNP.kt | 238 +- .../src/nativeGen/kotlin/godot/UPNPDevice.kt | 240 +- .../src/nativeGen/kotlin/godot/UndoRedo.kt | 240 +- .../src/nativeGen/kotlin/godot/VehicleBody.kt | 96 +- .../nativeGen/kotlin/godot/VehicleWheel.kt | 496 +- .../src/nativeGen/kotlin/godot/VideoPlayer.kt | 400 +- .../kotlin/godot/VideoStreamGDNative.kt | 32 +- .../kotlin/godot/VideoStreamTheora.kt | 32 +- .../nativeGen/kotlin/godot/VideoStreamWebm.kt | 32 +- .../src/nativeGen/kotlin/godot/Viewport.kt | 1160 ++-- .../kotlin/godot/ViewportContainer.kt | 64 +- .../nativeGen/kotlin/godot/ViewportTexture.kt | 32 +- .../kotlin/godot/VisibilityEnabler.kt | 32 +- .../kotlin/godot/VisibilityEnabler2D.kt | 32 +- .../kotlin/godot/VisibilityNotifier.kt | 48 +- .../kotlin/godot/VisibilityNotifier2D.kt | 48 +- .../nativeGen/kotlin/godot/VisualInstance.kt | 144 +- .../nativeGen/kotlin/godot/VisualScript.kt | 678 +- .../godot/VisualScriptBasicTypeConstant.kt | 64 +- .../kotlin/godot/VisualScriptBuiltinFunc.kt | 32 +- .../kotlin/godot/VisualScriptClassConstant.kt | 64 +- .../kotlin/godot/VisualScriptComment.kt | 96 +- .../kotlin/godot/VisualScriptConstant.kt | 64 +- .../kotlin/godot/VisualScriptConstructor.kt | 64 +- .../kotlin/godot/VisualScriptDeconstruct.kt | 32 +- .../kotlin/godot/VisualScriptEditor.kt | 32 +- .../kotlin/godot/VisualScriptEmitSignal.kt | 32 +- .../godot/VisualScriptEngineSingleton.kt | 32 +- .../kotlin/godot/VisualScriptFunctionCall.kt | 320 +- .../kotlin/godot/VisualScriptFunctionState.kt | 48 +- .../godot/VisualScriptGlobalConstant.kt | 32 +- .../kotlin/godot/VisualScriptInputAction.kt | 64 +- .../kotlin/godot/VisualScriptLists.kt | 128 +- .../kotlin/godot/VisualScriptLocalVar.kt | 64 +- .../kotlin/godot/VisualScriptLocalVarSet.kt | 64 +- .../kotlin/godot/VisualScriptMathConstant.kt | 32 +- .../kotlin/godot/VisualScriptNode.kt | 64 +- .../kotlin/godot/VisualScriptOperator.kt | 64 +- .../kotlin/godot/VisualScriptPreload.kt | 32 +- .../kotlin/godot/VisualScriptPropertyGet.kt | 224 +- .../kotlin/godot/VisualScriptPropertySet.kt | 256 +- .../kotlin/godot/VisualScriptResourcePath.kt | 32 +- .../kotlin/godot/VisualScriptReturn.kt | 64 +- .../kotlin/godot/VisualScriptSceneNode.kt | 32 +- .../kotlin/godot/VisualScriptSelect.kt | 32 +- .../kotlin/godot/VisualScriptSequence.kt | 32 +- .../kotlin/godot/VisualScriptTypeCast.kt | 64 +- .../kotlin/godot/VisualScriptVariableGet.kt | 32 +- .../kotlin/godot/VisualScriptVariableSet.kt | 32 +- .../kotlin/godot/VisualScriptYield.kt | 64 +- .../kotlin/godot/VisualScriptYieldSignal.kt | 128 +- .../nativeGen/kotlin/godot/VisualServer.kt | 5957 ++++++++++------- .../nativeGen/kotlin/godot/VisualShader.kt | 256 +- .../kotlin/godot/VisualShaderNode.kt | 96 +- .../godot/VisualShaderNodeBooleanConstant.kt | 32 +- .../godot/VisualShaderNodeColorConstant.kt | 32 +- .../kotlin/godot/VisualShaderNodeColorFunc.kt | 32 +- .../kotlin/godot/VisualShaderNodeColorOp.kt | 32 +- .../kotlin/godot/VisualShaderNodeCompare.kt | 96 +- .../kotlin/godot/VisualShaderNodeCubeMap.kt | 96 +- .../godot/VisualShaderNodeExpression.kt | 32 +- .../kotlin/godot/VisualShaderNodeGroupBase.kt | 368 +- .../kotlin/godot/VisualShaderNodeInput.kt | 48 +- .../kotlin/godot/VisualShaderNodeIs.kt | 32 +- .../godot/VisualShaderNodeScalarConstant.kt | 32 +- .../VisualShaderNodeScalarDerivativeFunc.kt | 32 +- .../godot/VisualShaderNodeScalarFunc.kt | 32 +- .../kotlin/godot/VisualShaderNodeScalarOp.kt | 32 +- .../kotlin/godot/VisualShaderNodeTexture.kt | 96 +- .../godot/VisualShaderNodeTextureUniform.kt | 64 +- .../VisualShaderNodeTransformConstant.kt | 32 +- .../godot/VisualShaderNodeTransformFunc.kt | 32 +- .../godot/VisualShaderNodeTransformMult.kt | 32 +- .../godot/VisualShaderNodeTransformVecMult.kt | 32 +- .../kotlin/godot/VisualShaderNodeUniform.kt | 32 +- .../godot/VisualShaderNodeVec3Constant.kt | 32 +- .../VisualShaderNodeVectorDerivativeFunc.kt | 32 +- .../godot/VisualShaderNodeVectorFunc.kt | 32 +- .../kotlin/godot/VisualShaderNodeVectorOp.kt | 32 +- .../src/nativeGen/kotlin/godot/WeakRef.kt | 15 +- .../kotlin/godot/WebRTCDataChannel.kt | 208 +- .../kotlin/godot/WebRTCMultiplayer.kt | 112 +- .../kotlin/godot/WebRTCPeerConnection.kt | 144 +- .../nativeGen/kotlin/godot/WebSocketClient.kt | 128 +- .../kotlin/godot/WebSocketMultiplayerPeer.kt | 32 +- .../nativeGen/kotlin/godot/WebSocketPeer.kt | 128 +- .../nativeGen/kotlin/godot/WebSocketServer.kt | 240 +- .../nativeGen/kotlin/godot/WindowDialog.kt | 80 +- .../src/nativeGen/kotlin/godot/World.kt | 98 +- .../src/nativeGen/kotlin/godot/World2D.kt | 45 +- .../kotlin/godot/WorldEnvironment.kt | 32 +- .../nativeGen/kotlin/godot/X509Certificate.kt | 32 +- .../src/nativeGen/kotlin/godot/XMLParser.kt | 256 +- .../src/nativeGen/kotlin/godot/YSort.kt | 28 +- 498 files changed, 65053 insertions(+), 48084 deletions(-) diff --git a/build-support/src/main/kotlin/godot/codegen/APIGenerator.kt b/build-support/src/main/kotlin/godot/codegen/APIGenerator.kt index 1cdc2fec..2cfec9ac 100644 --- a/build-support/src/main/kotlin/godot/codegen/APIGenerator.kt +++ b/build-support/src/main/kotlin/godot/codegen/APIGenerator.kt @@ -477,15 +477,24 @@ class APIGenerator { .filter { method -> !method.isVirtual } .map { method -> PropertySpec.builder(method.name, METHOD_BIND_TYPE) - .getter(FunSpec.getterBuilder() - .addCode(""" - return Allocator.allocationScope { + .delegate(""" + lazy { + Allocator.allocationScope { val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)(%S.cstr.ptr, %S.cstr.ptr) requireNotNull(ptr) { %S } } + } """.trimIndent(), cls.rawName, method.rawName, "No method_bind found for method ${method.rawName}") - .build() - ).build() + .build() +// .getter(FunSpec.getterBuilder() +// .addCode(""" +// return Allocator.allocationScope { +// val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)(%S.cstr.ptr, %S.cstr.ptr) +// requireNotNull(ptr) { %S } +// } +// """.trimIndent(), cls.rawName, method.rawName, "No method_bind found for method ${method.rawName}") +// .build() +// ).build() } builder.addProperties(methodBindProperties) diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ARVRAnchor.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ARVRAnchor.kt index 74ea5636..fc574d24 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ARVRAnchor.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ARVRAnchor.kt @@ -136,47 +136,68 @@ open class ARVRAnchor( * Container for method_bind pointers for ARVRAnchor */ private object __method_bind { - val getAnchorId: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRAnchor".cstr.ptr, - "get_anchor_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_anchor_id" } - } - val getAnchorName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRAnchor".cstr.ptr, - "get_anchor_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_anchor_name" } - } - val getIsActive: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRAnchor".cstr.ptr, - "get_is_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_is_active" } - } - val getMesh: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRAnchor".cstr.ptr, - "get_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mesh" } - } - val getPlane: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRAnchor".cstr.ptr, - "get_plane".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_plane" } - } - val getSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRAnchor".cstr.ptr, - "get_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_size" } - } - val setAnchorId: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRAnchor".cstr.ptr, - "set_anchor_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_anchor_id" } - }} + val getAnchorId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRAnchor".cstr.ptr, + "get_anchor_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_anchor_id" } + } + } + + val getAnchorName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRAnchor".cstr.ptr, + "get_anchor_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_anchor_name" } + } + } + + val getIsActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRAnchor".cstr.ptr, + "get_is_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_is_active" } + } + } + + val getMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRAnchor".cstr.ptr, + "get_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mesh" } + } + } + + val getPlane: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRAnchor".cstr.ptr, + "get_plane".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_plane" } + } + } + + val getSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRAnchor".cstr.ptr, + "get_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_size" } + } + } + + val setAnchorId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRAnchor".cstr.ptr, + "set_anchor_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_anchor_id" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ARVRController.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ARVRController.kt index 8db0726f..882aa4fa 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ARVRController.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ARVRController.kt @@ -189,82 +189,104 @@ open class ARVRController( * Container for method_bind pointers for ARVRController */ private object __method_bind { - val getControllerId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, - "get_controller_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_controller_id" } - } - val getControllerName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, - "get_controller_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_controller_name" } - } - val getHand: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, - "get_hand".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_hand" } - } - val getIsActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, - "get_is_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_is_active" } - } - val getJoystickAxis: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, - "get_joystick_axis".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_joystick_axis" } - } - val getJoystickId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, - "get_joystick_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_joystick_id" } - } - val getMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, - "get_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mesh" } - } - val getRumble: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, - "get_rumble".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rumble" } - } - val isButtonPressed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, - "is_button_pressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_button_pressed" } - } - val setControllerId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, - "set_controller_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_controller_id" } - } - val setRumble: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, - "set_rumble".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rumble" } - }} + val getControllerId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, + "get_controller_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_controller_id" } + } + } + + val getControllerName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, + "get_controller_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_controller_name" } + } + } + + val getHand: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, + "get_hand".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_hand" } + } + } + + val getIsActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, + "get_is_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_is_active" } + } + } + + val getJoystickAxis: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, + "get_joystick_axis".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_joystick_axis" } + } + } + + val getJoystickId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, + "get_joystick_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_joystick_id" } + } + } + + val getMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, + "get_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mesh" } + } + } + + val getRumble: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, + "get_rumble".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rumble" } + } + } + + val isButtonPressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, + "is_button_pressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_button_pressed" } + } + } + + val setControllerId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, + "set_controller_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_controller_id" } + } + } + + val setRumble: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRController".cstr.ptr, + "set_rumble".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rumble" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ARVRInterface.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ARVRInterface.kt index 15d61824..6a744640 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ARVRInterface.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ARVRInterface.kt @@ -269,103 +269,133 @@ open class ARVRInterface( * Container for method_bind pointers for ARVRInterface */ private object __method_bind { - val getAnchorDetectionIsEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, - "get_anchor_detection_is_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_anchor_detection_is_enabled" } - } - val getCameraFeedId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, - "get_camera_feed_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_camera_feed_id" } - } - val getCapabilities: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, - "get_capabilities".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_capabilities" } - } - val getName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, - "get_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_name" } - } - val getRenderTargetsize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, - "get_render_targetsize".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_render_targetsize" } - } - val getTrackingStatus: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, - "get_tracking_status".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tracking_status" } - } - val initialize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, - "initialize".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method initialize" } - } - val isInitialized: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, - "is_initialized".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_initialized" } - } - val isPrimary: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, - "is_primary".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_primary" } - } - val isStereo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, - "is_stereo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_stereo" } - } - val setAnchorDetectionIsEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, - "set_anchor_detection_is_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_anchor_detection_is_enabled" } - } - val setIsInitialized: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, - "set_is_initialized".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_is_initialized" } - } - val setIsPrimary: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, - "set_is_primary".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_is_primary" } - } - val uninitialize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, - "uninitialize".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method uninitialize" } - }} + val getAnchorDetectionIsEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, + "get_anchor_detection_is_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_anchor_detection_is_enabled" } + } + } + + val getCameraFeedId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, + "get_camera_feed_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_camera_feed_id" } + } + } + + val getCapabilities: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, + "get_capabilities".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_capabilities" } + } + } + + val getName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, + "get_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_name" } + } + } + + val getRenderTargetsize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, + "get_render_targetsize".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_render_targetsize" } + } + } + + val getTrackingStatus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, + "get_tracking_status".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tracking_status" } + } + } + + val initialize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, + "initialize".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method initialize" } + } + } + + val isInitialized: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, + "is_initialized".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_initialized" } + } + } + + val isPrimary: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, + "is_primary".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_primary" } + } + } + + val isStereo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, + "is_stereo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_stereo" } + } + } + + val setAnchorDetectionIsEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, + "set_anchor_detection_is_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_anchor_detection_is_enabled" } + } + } + + val setIsInitialized: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, + "set_is_initialized".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_is_initialized" } + } + } + + val setIsPrimary: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, + "set_is_primary".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_is_primary" } + } + } + + val uninitialize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRInterface".cstr.ptr, + "uninitialize".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method uninitialize" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ARVROrigin.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ARVROrigin.kt index 26fddf89..9976206f 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ARVROrigin.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ARVROrigin.kt @@ -73,17 +73,23 @@ open class ARVROrigin( * Container for method_bind pointers for ARVROrigin */ private object __method_bind { - val getWorldScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVROrigin".cstr.ptr, - "get_world_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_world_scale" } - } - val setWorldScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVROrigin".cstr.ptr, - "set_world_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_world_scale" } - }} + val getWorldScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVROrigin".cstr.ptr, + "get_world_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_world_scale" } + } + } + + val setWorldScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVROrigin".cstr.ptr, + "set_world_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_world_scale" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ARVRPositionalTracker.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ARVRPositionalTracker.kt index bc0f0ce8..9daf373c 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ARVRPositionalTracker.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ARVRPositionalTracker.kt @@ -230,89 +230,113 @@ open class ARVRPositionalTracker( * Container for method_bind pointers for ARVRPositionalTracker */ private object __method_bind { - val getHand: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, - "get_hand".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_hand" } - } - val getJoyId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, - "get_joy_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_joy_id" } - } - val getMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, - "get_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mesh" } - } - val getName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, - "get_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_name" } - } - val getOrientation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, - "get_orientation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_orientation" } - } - val getPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, - "get_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_position" } - } - val getRumble: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, - "get_rumble".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rumble" } - } - val getTracksOrientation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, - "get_tracks_orientation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tracks_orientation" } - } - val getTracksPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, - "get_tracks_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tracks_position" } - } - val getTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, - "get_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_transform" } - } - val getType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, - "get_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_type" } - } - val setRumble: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, - "set_rumble".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rumble" } - }} + val getHand: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, + "get_hand".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_hand" } + } + } + + val getJoyId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, + "get_joy_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_joy_id" } + } + } + + val getMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, + "get_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mesh" } + } + } + + val getName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, + "get_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_name" } + } + } + + val getOrientation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, + "get_orientation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_orientation" } + } + } + + val getPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, + "get_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_position" } + } + } + + val getRumble: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, + "get_rumble".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rumble" } + } + } + + val getTracksOrientation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, + "get_tracks_orientation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tracks_orientation" } + } + } + + val getTracksPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, + "get_tracks_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tracks_position" } + } + } + + val getTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, + "get_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_transform" } + } + } + + val getType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, + "get_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_type" } + } + } + + val setRumble: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRPositionalTracker".cstr.ptr, + "set_rumble".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rumble" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ARVRServer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ARVRServer.kt index 36918b92..0e5b449a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ARVRServer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ARVRServer.kt @@ -240,102 +240,150 @@ open class ARVRServerInternal( * Container for method_bind pointers for ARVRServer */ private object __method_bind { - val centerOnHmd: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, - "center_on_hmd".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method center_on_hmd" } - } - val findInterface: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, - "find_interface".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method find_interface" } - } - val getHmdTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, - "get_hmd_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_hmd_transform" } - } - val getInterface: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, - "get_interface".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_interface" } - } - val getInterfaceCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, - "get_interface_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_interface_count" } - } - val getInterfaces: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, - "get_interfaces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_interfaces" } - } - val getLastCommitUsec: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, - "get_last_commit_usec".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_last_commit_usec" } - } - val getLastFrameUsec: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, - "get_last_frame_usec".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_last_frame_usec" } - } - val getLastProcessUsec: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, - "get_last_process_usec".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_last_process_usec" } - } - val getPrimaryInterface: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, - "get_primary_interface".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_primary_interface" } - } - val getReferenceFrame: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, - "get_reference_frame".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_reference_frame" } - } - val getTracker: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, - "get_tracker".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tracker" } - } - val getTrackerCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, - "get_tracker_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tracker_count" } - } - val getWorldScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, - "get_world_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_world_scale" } - } - val setPrimaryInterface: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, - "set_primary_interface".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_primary_interface" } - } - val setWorldScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, - "set_world_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_world_scale" } - }} + val centerOnHmd: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, + "center_on_hmd".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method center_on_hmd" } + } + } + + val findInterface: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, + "find_interface".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method find_interface" } + } + } + + val getHmdTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, + "get_hmd_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_hmd_transform" } + } + } + + val getInterface: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, + "get_interface".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_interface" } + } + } + + val getInterfaceCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, + "get_interface_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_interface_count" } + } + } + + val getInterfaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, + "get_interfaces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_interfaces" } + } + } + + val getLastCommitUsec: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, + "get_last_commit_usec".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_last_commit_usec" } + } + } + + val getLastFrameUsec: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, + "get_last_frame_usec".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_last_frame_usec" } + } + } + + val getLastProcessUsec: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, + "get_last_process_usec".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_last_process_usec" } + } + } + + val getPrimaryInterface: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, + "get_primary_interface".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_primary_interface" } + } + } + + val getReferenceFrame: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, + "get_reference_frame".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_reference_frame" } + } + } + + val getTracker: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, + "get_tracker".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tracker" } + } + } + + val getTrackerCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, + "get_tracker_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tracker_count" } + } + } + + val getWorldScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, + "get_world_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_world_scale" } + } + } + + val setPrimaryInterface: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, + "set_primary_interface".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_primary_interface" } + } + } + + val setWorldScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ARVRServer".cstr.ptr, + "set_world_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_world_scale" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AStar.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AStar.kt index 147eb877..28061747 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AStar.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AStar.kt @@ -320,143 +320,190 @@ open class AStar( * Container for method_bind pointers for AStar */ private object __method_bind { - val addPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "add_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_point" } - } - val arePointsConnected: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "are_points_connected".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method are_points_connected" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val connectPoints: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "connect_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method connect_points" } - } - val disconnectPoints: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "disconnect_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method disconnect_points" } - } - val getAvailablePointId: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "get_available_point_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_available_point_id" } - } - val getClosestPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "get_closest_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_closest_point" } - } - val getClosestPositionInSegment: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "get_closest_position_in_segment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_closest_position_in_segment" } - } - val getIdPath: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "get_id_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_id_path" } - } - val getPointCapacity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "get_point_capacity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_capacity" } - } - val getPointConnections: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "get_point_connections".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_connections" } - } - val getPointCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "get_point_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_count" } - } - val getPointPath: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "get_point_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_path" } - } - val getPointPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "get_point_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_position" } - } - val getPointWeightScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "get_point_weight_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_weight_scale" } - } - val getPoints: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "get_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_points" } - } - val hasPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "has_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_point" } - } - val isPointDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "is_point_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_point_disabled" } - } - val removePoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "remove_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_point" } - } - val reserveSpace: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "reserve_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method reserve_space" } - } - val setPointDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "set_point_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_disabled" } - } - val setPointPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "set_point_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_position" } - } - val setPointWeightScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, - "set_point_weight_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_weight_scale" } - }} + val addPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "add_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_point" } + } + } + + val arePointsConnected: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "are_points_connected".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method are_points_connected" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val connectPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "connect_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method connect_points" } + } + } + + val disconnectPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "disconnect_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method disconnect_points" } + } + } + + val getAvailablePointId: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "get_available_point_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_available_point_id" } + } + } + + val getClosestPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "get_closest_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_closest_point" } + } + } + + val getClosestPositionInSegment: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "get_closest_position_in_segment".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_closest_position_in_segment" } + } + } + + val getIdPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "get_id_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_id_path" } + } + } + + val getPointCapacity: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "get_point_capacity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_capacity" } + } + } + + val getPointConnections: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "get_point_connections".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_connections" } + } + } + + val getPointCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "get_point_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_count" } + } + } + + val getPointPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "get_point_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_path" } + } + } + + val getPointPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "get_point_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_position" } + } + } + + val getPointWeightScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "get_point_weight_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_weight_scale" } + } + } + + val getPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "get_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_points" } + } + } + + val hasPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "has_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_point" } + } + } + + val isPointDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "is_point_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_point_disabled" } + } + } + + val removePoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "remove_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_point" } + } + } + + val reserveSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "reserve_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method reserve_space" } + } + } + + val setPointDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "set_point_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_disabled" } + } + } + + val setPointPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "set_point_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_position" } + } + } + + val setPointWeightScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar".cstr.ptr, + "set_point_weight_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_weight_scale" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AStar2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AStar2D.kt index e72eef8c..694d62c1 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AStar2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AStar2D.kt @@ -302,143 +302,213 @@ open class AStar2D( * Container for method_bind pointers for AStar2D */ private object __method_bind { - val addPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "add_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_point" } - } - val arePointsConnected: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "are_points_connected".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method are_points_connected" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val connectPoints: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "connect_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method connect_points" } - } - val disconnectPoints: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "disconnect_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method disconnect_points" } - } - val getAvailablePointId: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "get_available_point_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_available_point_id" } - } - val getClosestPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "get_closest_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_closest_point" } - } - val getClosestPositionInSegment: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "get_closest_position_in_segment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_closest_position_in_segment" } - } - val getIdPath: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "get_id_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_id_path" } - } - val getPointCapacity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "get_point_capacity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_capacity" } - } - val getPointConnections: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "get_point_connections".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_connections" } - } - val getPointCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "get_point_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_count" } - } - val getPointPath: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "get_point_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_path" } - } - val getPointPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "get_point_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_position" } - } - val getPointWeightScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "get_point_weight_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_weight_scale" } - } - val getPoints: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "get_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_points" } - } - val hasPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "has_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_point" } - } - val isPointDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "is_point_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_point_disabled" } - } - val removePoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "remove_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_point" } - } - val reserveSpace: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "reserve_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method reserve_space" } - } - val setPointDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "set_point_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_disabled" } - } - val setPointPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "set_point_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_position" } - } - val setPointWeightScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, - "set_point_weight_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_weight_scale" } - }} + val addPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "add_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_point" } + } + } + + val arePointsConnected: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "are_points_connected".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method are_points_connected" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val connectPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "connect_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method connect_points" } + } + } + + val disconnectPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "disconnect_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method disconnect_points" } + } + } + + val getAvailablePointId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "get_available_point_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_available_point_id" } + } + } + + val getClosestPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "get_closest_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_closest_point" } + } + } + + val getClosestPositionInSegment: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "get_closest_position_in_segment".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_closest_position_in_segment" } + } + } + + val getIdPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "get_id_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_id_path" } + } + } + + val getPointCapacity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "get_point_capacity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_capacity" } + } + } + + val getPointConnections: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "get_point_connections".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_connections" } + } + } + + val getPointCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "get_point_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_count" } + } + } + + val getPointPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "get_point_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_path" } + } + } + + val getPointPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "get_point_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_position" } + } + } + + val getPointWeightScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "get_point_weight_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_weight_scale" } + } + } + + val getPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "get_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_points" } + } + } + + val hasPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "has_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_point" } + } + } + + val isPointDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "is_point_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_point_disabled" } + } + } + + val removePoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "remove_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_point" } + } + } + + val reserveSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "reserve_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method reserve_space" } + } + } + + val setPointDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "set_point_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_disabled" } + } + } + + val setPointPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "set_point_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_position" } + } + } + + val setPointWeightScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AStar2D".cstr.ptr, + "set_point_weight_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_weight_scale" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AcceptDialog.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AcceptDialog.kt index d5479893..95891e0b 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AcceptDialog.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AcceptDialog.kt @@ -209,82 +209,104 @@ open class AcceptDialog( * Container for method_bind pointers for AcceptDialog */ private object __method_bind { - val addButton: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, - "add_button".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_button" } - } - val addCancel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, - "add_cancel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_cancel" } - } - val getHideOnOk: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, - "get_hide_on_ok".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_hide_on_ok" } - } - val getLabel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, - "get_label".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_label" } - } - val getOk: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, - "get_ok".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ok" } - } - val getText: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, - "get_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_text" } - } - val hasAutowrap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, - "has_autowrap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_autowrap" } - } - val registerTextEnter: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, - "register_text_enter".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method register_text_enter" } - } - val setAutowrap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, - "set_autowrap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_autowrap" } - } - val setHideOnOk: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, - "set_hide_on_ok".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_hide_on_ok" } - } - val setText: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, - "set_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_text" } - }} + val addButton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, + "add_button".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_button" } + } + } + + val addCancel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, + "add_cancel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_cancel" } + } + } + + val getHideOnOk: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, + "get_hide_on_ok".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_hide_on_ok" } + } + } + + val getLabel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, + "get_label".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_label" } + } + } + + val getOk: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, + "get_ok".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ok" } + } + } + + val getText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, + "get_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_text" } + } + } + + val hasAutowrap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, + "has_autowrap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_autowrap" } + } + } + + val registerTextEnter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, + "register_text_enter".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method register_text_enter" } + } + } + + val setAutowrap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, + "set_autowrap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_autowrap" } + } + } + + val setHideOnOk: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, + "set_hide_on_ok".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_hide_on_ok" } + } + } + + val setText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AcceptDialog".cstr.ptr, + "set_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_text" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimatedSprite.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimatedSprite.kt index 3fd1f949..1bb86d4a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimatedSprite.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimatedSprite.kt @@ -315,138 +315,176 @@ open class AnimatedSprite( * Container for method_bind pointers for AnimatedSprite */ private object __method_bind { - val getAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, - "get_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_animation" } - } - val getFrame: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, - "get_frame".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_frame" } - } - val getOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, - "get_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_offset" } - } - val getSpeedScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, - "get_speed_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_speed_scale" } - } - val getSpriteFrames: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, - "get_sprite_frames".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sprite_frames" } - } - val isCentered: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, - "is_centered".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_centered" } - } - val isFlippedH: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, - "is_flipped_h".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_flipped_h" } - } - val isFlippedV: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, - "is_flipped_v".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_flipped_v" } - } - val isPlaying: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, - "is_playing".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_playing" } - } - val play: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, - "play".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method play" } - } - val setAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, - "set_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_animation" } - } - val setCentered: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, - "set_centered".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_centered" } - } - val setFlipH: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, - "set_flip_h".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flip_h" } - } - val setFlipV: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, - "set_flip_v".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flip_v" } - } - val setFrame: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, - "set_frame".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_frame" } - } - val setOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, - "set_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_offset" } - } - val setSpeedScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, - "set_speed_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_speed_scale" } - } - val setSpriteFrames: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, - "set_sprite_frames".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sprite_frames" } - } - val stop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, - "stop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method stop" } - }} + val getAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, + "get_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_animation" } + } + } + + val getFrame: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, + "get_frame".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_frame" } + } + } + + val getOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, + "get_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_offset" } + } + } + + val getSpeedScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, + "get_speed_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_speed_scale" } + } + } + + val getSpriteFrames: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, + "get_sprite_frames".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sprite_frames" } + } + } + + val isCentered: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, + "is_centered".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_centered" } + } + } + + val isFlippedH: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, + "is_flipped_h".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_flipped_h" } + } + } + + val isFlippedV: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, + "is_flipped_v".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_flipped_v" } + } + } + + val isPlaying: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, + "is_playing".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_playing" } + } + } + + val play: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, + "play".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method play" } + } + } + + val setAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, + "set_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_animation" } + } + } + + val setCentered: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, + "set_centered".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_centered" } + } + } + + val setFlipH: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, + "set_flip_h".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flip_h" } + } + } + + val setFlipV: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, + "set_flip_v".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flip_v" } + } + } + + val setFrame: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, + "set_frame".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_frame" } + } + } + + val setOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, + "set_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_offset" } + } + } + + val setSpeedScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, + "set_speed_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_speed_scale" } + } + } + + val setSpriteFrames: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, + "set_sprite_frames".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sprite_frames" } + } + } + + val stop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite".cstr.ptr, + "stop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method stop" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimatedSprite3D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimatedSprite3D.kt index 6ace3167..c011c848 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimatedSprite3D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimatedSprite3D.kt @@ -169,68 +169,86 @@ open class AnimatedSprite3D( * Container for method_bind pointers for AnimatedSprite3D */ private object __method_bind { - val getAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite3D".cstr.ptr, - "get_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_animation" } - } - val getFrame: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite3D".cstr.ptr, - "get_frame".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_frame" } - } - val getSpriteFrames: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite3D".cstr.ptr, - "get_sprite_frames".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sprite_frames" } - } - val isPlaying: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite3D".cstr.ptr, - "is_playing".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_playing" } - } - val play: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite3D".cstr.ptr, - "play".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method play" } - } - val setAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite3D".cstr.ptr, - "set_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_animation" } - } - val setFrame: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite3D".cstr.ptr, - "set_frame".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_frame" } - } - val setSpriteFrames: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite3D".cstr.ptr, - "set_sprite_frames".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sprite_frames" } - } - val stop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite3D".cstr.ptr, - "stop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method stop" } - }} + val getAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite3D".cstr.ptr, + "get_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_animation" } + } + } + + val getFrame: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite3D".cstr.ptr, + "get_frame".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_frame" } + } + } + + val getSpriteFrames: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite3D".cstr.ptr, + "get_sprite_frames".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sprite_frames" } + } + } + + val isPlaying: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite3D".cstr.ptr, + "is_playing".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_playing" } + } + } + + val play: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite3D".cstr.ptr, + "play".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method play" } + } + } + + val setAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite3D".cstr.ptr, + "set_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_animation" } + } + } + + val setFrame: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite3D".cstr.ptr, + "set_frame".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_frame" } + } + } + + val setSpriteFrames: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite3D".cstr.ptr, + "set_sprite_frames".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sprite_frames" } + } + } + + val stop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedSprite3D".cstr.ptr, + "stop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method stop" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimatedTexture.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimatedTexture.kt index ad3583fc..d3045743 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimatedTexture.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimatedTexture.kt @@ -4244,61 +4244,77 @@ open class AnimatedTexture( * Container for method_bind pointers for AnimatedTexture */ private object __method_bind { - val getFps: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedTexture".cstr.ptr, - "get_fps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fps" } - } - val getFrameDelay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedTexture".cstr.ptr, - "get_frame_delay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_frame_delay" } - } - val getFrameTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedTexture".cstr.ptr, - "get_frame_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_frame_texture" } - } - val getFrames: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedTexture".cstr.ptr, - "get_frames".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_frames" } - } - val setFps: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedTexture".cstr.ptr, - "set_fps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fps" } - } - val setFrameDelay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedTexture".cstr.ptr, - "set_frame_delay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_frame_delay" } - } - val setFrameTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedTexture".cstr.ptr, - "set_frame_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_frame_texture" } - } - val setFrames: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedTexture".cstr.ptr, - "set_frames".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_frames" } - }} + val getFps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedTexture".cstr.ptr, + "get_fps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fps" } + } + } + + val getFrameDelay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedTexture".cstr.ptr, + "get_frame_delay".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_frame_delay" } + } + } + + val getFrameTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedTexture".cstr.ptr, + "get_frame_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_frame_texture" } + } + } + + val getFrames: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedTexture".cstr.ptr, + "get_frames".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_frames" } + } + } + + val setFps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedTexture".cstr.ptr, + "set_fps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fps" } + } + } + + val setFrameDelay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedTexture".cstr.ptr, + "set_frame_delay".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_frame_delay" } + } + } + + val setFrameTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedTexture".cstr.ptr, + "set_frame_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_frame_texture" } + } + } + + val setFrames: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimatedTexture".cstr.ptr, + "set_frames".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_frames" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Animation.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Animation.kt index bb065700..912446ba 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Animation.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Animation.kt @@ -956,393 +956,593 @@ open class Animation( * Container for method_bind pointers for Animation */ private object __method_bind { - val addTrack: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "add_track".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_track" } - } - val animationTrackGetKeyAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "animation_track_get_key_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method animation_track_get_key_animation" + val addTrack: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "add_track".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_track" } } - } - val animationTrackInsertKey: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "animation_track_insert_key".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method animation_track_insert_key" } - } - val animationTrackSetKeyAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "animation_track_set_key_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method animation_track_set_key_animation" + } + + val animationTrackGetKeyAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "animation_track_get_key_animation".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method animation_track_get_key_animation" } } - } - val audioTrackGetKeyEndOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "audio_track_get_key_end_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method audio_track_get_key_end_offset" } - } - val audioTrackGetKeyStartOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "audio_track_get_key_start_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method audio_track_get_key_start_offset" } - } - val audioTrackGetKeyStream: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "audio_track_get_key_stream".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method audio_track_get_key_stream" } - } - val audioTrackInsertKey: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "audio_track_insert_key".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method audio_track_insert_key" } - } - val audioTrackSetKeyEndOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "audio_track_set_key_end_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method audio_track_set_key_end_offset" } - } - val audioTrackSetKeyStartOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "audio_track_set_key_start_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method audio_track_set_key_start_offset" } - } - val audioTrackSetKeyStream: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "audio_track_set_key_stream".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method audio_track_set_key_stream" } - } - val bezierTrackGetKeyInHandle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "bezier_track_get_key_in_handle".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method bezier_track_get_key_in_handle" } - } - val bezierTrackGetKeyOutHandle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "bezier_track_get_key_out_handle".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method bezier_track_get_key_out_handle" } - } - val bezierTrackGetKeyValue: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "bezier_track_get_key_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method bezier_track_get_key_value" } - } - val bezierTrackInsertKey: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "bezier_track_insert_key".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method bezier_track_insert_key" } - } - val bezierTrackInterpolate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "bezier_track_interpolate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method bezier_track_interpolate" } - } - val bezierTrackSetKeyInHandle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "bezier_track_set_key_in_handle".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method bezier_track_set_key_in_handle" } - } - val bezierTrackSetKeyOutHandle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "bezier_track_set_key_out_handle".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method bezier_track_set_key_out_handle" } - } - val bezierTrackSetKeyValue: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "bezier_track_set_key_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method bezier_track_set_key_value" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val copyTrack: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "copy_track".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method copy_track" } - } - val findTrack: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "find_track".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method find_track" } - } - val getLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "get_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_length" } - } - val getStep: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "get_step".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_step" } - } - val getTrackCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "get_track_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_track_count" } - } - val hasLoop: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "has_loop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_loop" } - } - val methodTrackGetKeyIndices: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "method_track_get_key_indices".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method method_track_get_key_indices" } - } - val methodTrackGetName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "method_track_get_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method method_track_get_name" } - } - val methodTrackGetParams: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "method_track_get_params".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method method_track_get_params" } - } - val removeTrack: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "remove_track".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_track" } - } - val setLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "set_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_length" } - } - val setLoop: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "set_loop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_loop" } - } - val setStep: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "set_step".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_step" } - } - val trackFindKey: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_find_key".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_find_key" } - } - val trackGetInterpolationLoopWrap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_get_interpolation_loop_wrap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_get_interpolation_loop_wrap" + } + + val animationTrackInsertKey: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "animation_track_insert_key".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method animation_track_insert_key" } } - } - val trackGetInterpolationType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_get_interpolation_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_get_interpolation_type" } - } - val trackGetKeyCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_get_key_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_get_key_count" } - } - val trackGetKeyTime: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_get_key_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_get_key_time" } - } - val trackGetKeyTransition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_get_key_transition".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_get_key_transition" } - } - val trackGetKeyValue: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_get_key_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_get_key_value" } - } - val trackGetPath: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_get_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_get_path" } - } - val trackGetType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_get_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_get_type" } - } - val trackInsertKey: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_insert_key".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_insert_key" } - } - val trackIsEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_is_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_is_enabled" } - } - val trackIsImported: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_is_imported".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_is_imported" } - } - val trackMoveDown: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_move_down".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_move_down" } - } - val trackMoveTo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_move_to".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_move_to" } - } - val trackMoveUp: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_move_up".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_move_up" } - } - val trackRemoveKey: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_remove_key".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_remove_key" } - } - val trackRemoveKeyAtPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_remove_key_at_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_remove_key_at_position" } - } - val trackSetEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_set_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_set_enabled" } - } - val trackSetImported: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_set_imported".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_set_imported" } - } - val trackSetInterpolationLoopWrap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_set_interpolation_loop_wrap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_set_interpolation_loop_wrap" + } + + val animationTrackSetKeyAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "animation_track_set_key_animation".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method animation_track_set_key_animation" } } - } - val trackSetInterpolationType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_set_interpolation_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_set_interpolation_type" } - } - val trackSetKeyTime: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_set_key_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_set_key_time" } - } - val trackSetKeyTransition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_set_key_transition".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_set_key_transition" } - } - val trackSetKeyValue: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_set_key_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_set_key_value" } - } - val trackSetPath: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_set_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_set_path" } - } - val trackSwap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "track_swap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method track_swap" } - } - val transformTrackInsertKey: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "transform_track_insert_key".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method transform_track_insert_key" } - } - val transformTrackInterpolate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "transform_track_interpolate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method transform_track_interpolate" } - } - val valueTrackGetKeyIndices: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "value_track_get_key_indices".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method value_track_get_key_indices" } - } - val valueTrackGetUpdateMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "value_track_get_update_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method value_track_get_update_mode" } - } - val valueTrackSetUpdateMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, - "value_track_set_update_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method value_track_set_update_mode" } - }} + } + + val audioTrackGetKeyEndOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "audio_track_get_key_end_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method audio_track_get_key_end_offset" + } + } + } + + val audioTrackGetKeyStartOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "audio_track_get_key_start_offset".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method audio_track_get_key_start_offset" } + } + } + + val audioTrackGetKeyStream: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "audio_track_get_key_stream".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method audio_track_get_key_stream" } + } + } + + val audioTrackInsertKey: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "audio_track_insert_key".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method audio_track_insert_key" } + } + } + + val audioTrackSetKeyEndOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "audio_track_set_key_end_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method audio_track_set_key_end_offset" + } + } + } + + val audioTrackSetKeyStartOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "audio_track_set_key_start_offset".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method audio_track_set_key_start_offset" } + } + } + + val audioTrackSetKeyStream: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "audio_track_set_key_stream".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method audio_track_set_key_stream" } + } + } + + val bezierTrackGetKeyInHandle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "bezier_track_get_key_in_handle".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method bezier_track_get_key_in_handle" + } + } + } + + val bezierTrackGetKeyOutHandle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "bezier_track_get_key_out_handle".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method bezier_track_get_key_out_handle" } + } + } + + val bezierTrackGetKeyValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "bezier_track_get_key_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method bezier_track_get_key_value" } + } + } + + val bezierTrackInsertKey: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "bezier_track_insert_key".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method bezier_track_insert_key" } + } + } + + val bezierTrackInterpolate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "bezier_track_interpolate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method bezier_track_interpolate" } + } + } + + val bezierTrackSetKeyInHandle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "bezier_track_set_key_in_handle".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method bezier_track_set_key_in_handle" + } + } + } + + val bezierTrackSetKeyOutHandle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "bezier_track_set_key_out_handle".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method bezier_track_set_key_out_handle" } + } + } + + val bezierTrackSetKeyValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "bezier_track_set_key_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method bezier_track_set_key_value" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val copyTrack: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "copy_track".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method copy_track" } + } + } + + val findTrack: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "find_track".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method find_track" } + } + } + + val getLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "get_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_length" } + } + } + + val getStep: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "get_step".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_step" } + } + } + + val getTrackCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "get_track_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_track_count" } + } + } + + val hasLoop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "has_loop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_loop" } + } + } + + val methodTrackGetKeyIndices: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "method_track_get_key_indices".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method method_track_get_key_indices" } + } + } + + val methodTrackGetName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "method_track_get_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method method_track_get_name" } + } + } + + val methodTrackGetParams: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "method_track_get_params".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method method_track_get_params" } + } + } + + val removeTrack: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "remove_track".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_track" } + } + } + + val setLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "set_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_length" } + } + } + + val setLoop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "set_loop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_loop" } + } + } + + val setStep: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "set_step".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_step" } + } + } + + val trackFindKey: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_find_key".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_find_key" } + } + } + + val trackGetInterpolationLoopWrap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_get_interpolation_loop_wrap".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method track_get_interpolation_loop_wrap" } + } + } + + val trackGetInterpolationType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_get_interpolation_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_get_interpolation_type" } + } + } + + val trackGetKeyCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_get_key_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_get_key_count" } + } + } + + val trackGetKeyTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_get_key_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_get_key_time" } + } + } + + val trackGetKeyTransition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_get_key_transition".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_get_key_transition" } + } + } + + val trackGetKeyValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_get_key_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_get_key_value" } + } + } + + val trackGetPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_get_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_get_path" } + } + } + + val trackGetType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_get_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_get_type" } + } + } + + val trackInsertKey: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_insert_key".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_insert_key" } + } + } + + val trackIsEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_is_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_is_enabled" } + } + } + + val trackIsImported: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_is_imported".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_is_imported" } + } + } + + val trackMoveDown: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_move_down".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_move_down" } + } + } + + val trackMoveTo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_move_to".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_move_to" } + } + } + + val trackMoveUp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_move_up".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_move_up" } + } + } + + val trackRemoveKey: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_remove_key".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_remove_key" } + } + } + + val trackRemoveKeyAtPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_remove_key_at_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_remove_key_at_position" } + } + } + + val trackSetEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_set_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_set_enabled" } + } + } + + val trackSetImported: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_set_imported".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_set_imported" } + } + } + + val trackSetInterpolationLoopWrap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_set_interpolation_loop_wrap".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method track_set_interpolation_loop_wrap" } + } + } + + val trackSetInterpolationType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_set_interpolation_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_set_interpolation_type" } + } + } + + val trackSetKeyTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_set_key_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_set_key_time" } + } + } + + val trackSetKeyTransition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_set_key_transition".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_set_key_transition" } + } + } + + val trackSetKeyValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_set_key_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_set_key_value" } + } + } + + val trackSetPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_set_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_set_path" } + } + } + + val trackSwap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "track_swap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method track_swap" } + } + } + + val transformTrackInsertKey: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "transform_track_insert_key".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method transform_track_insert_key" } + } + } + + val transformTrackInterpolate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "transform_track_interpolate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method transform_track_interpolate" } + } + } + + val valueTrackGetKeyIndices: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "value_track_get_key_indices".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method value_track_get_key_indices" } + } + } + + val valueTrackGetUpdateMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "value_track_get_update_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method value_track_get_update_mode" } + } + } + + val valueTrackSetUpdateMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Animation".cstr.ptr, + "value_track_set_update_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method value_track_set_update_mode" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNode.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNode.kt index bb3d5f4b..01e037e8 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNode.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNode.kt @@ -291,96 +291,122 @@ open class AnimationNode( * Container for method_bind pointers for AnimationNode */ private object __method_bind { - val addInput: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, - "add_input".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_input" } - } - val blendAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, - "blend_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method blend_animation" } - } - val blendInput: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, - "blend_input".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method blend_input" } - } - val blendNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, - "blend_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method blend_node" } - } - val getInputCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, - "get_input_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_input_count" } - } - val getInputName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, - "get_input_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_input_name" } - } - val getParameter: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, - "get_parameter".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_parameter" } - } - val isFilterEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, - "is_filter_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_filter_enabled" } - } - val isPathFiltered: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, - "is_path_filtered".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_path_filtered" } - } - val removeInput: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, - "remove_input".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_input" } - } - val setFilterEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, - "set_filter_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_filter_enabled" } - } - val setFilterPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, - "set_filter_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_filter_path" } - } - val setParameter: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, - "set_parameter".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_parameter" } - }} + val addInput: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, + "add_input".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_input" } + } + } + + val blendAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, + "blend_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method blend_animation" } + } + } + + val blendInput: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, + "blend_input".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method blend_input" } + } + } + + val blendNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, + "blend_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method blend_node" } + } + } + + val getInputCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, + "get_input_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_input_count" } + } + } + + val getInputName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, + "get_input_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_input_name" } + } + } + + val getParameter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, + "get_parameter".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_parameter" } + } + } + + val isFilterEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, + "is_filter_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_filter_enabled" } + } + } + + val isPathFiltered: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, + "is_path_filtered".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_path_filtered" } + } + } + + val removeInput: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, + "remove_input".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_input" } + } + } + + val setFilterEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, + "set_filter_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_filter_enabled" } + } + } + + val setFilterPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, + "set_filter_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_filter_path" } + } + } + + val setParameter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNode".cstr.ptr, + "set_parameter".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_parameter" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeAdd2.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeAdd2.kt index 857e0c35..3ba60ba4 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeAdd2.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeAdd2.kt @@ -74,19 +74,23 @@ open class AnimationNodeAdd2( * Container for method_bind pointers for AnimationNodeAdd2 */ private object __method_bind { - val isUsingSync: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeAdd2".cstr.ptr, - "is_using_sync".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_using_sync" } - } - val setUseSync: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeAdd2".cstr.ptr, - "set_use_sync".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_sync" } - }} + val isUsingSync: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeAdd2".cstr.ptr, + "is_using_sync".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_using_sync" } + } + } + + val setUseSync: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeAdd2".cstr.ptr, + "set_use_sync".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_sync" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeAdd3.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeAdd3.kt index 0520fb44..cd36d61c 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeAdd3.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeAdd3.kt @@ -74,19 +74,23 @@ open class AnimationNodeAdd3( * Container for method_bind pointers for AnimationNodeAdd3 */ private object __method_bind { - val isUsingSync: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeAdd3".cstr.ptr, - "is_using_sync".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_using_sync" } - } - val setUseSync: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeAdd3".cstr.ptr, - "set_use_sync".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_sync" } - }} + val isUsingSync: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeAdd3".cstr.ptr, + "is_using_sync".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_using_sync" } + } + } + + val setUseSync: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeAdd3".cstr.ptr, + "set_use_sync".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_sync" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeAnimation.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeAnimation.kt index 1c253c96..fad13439 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeAnimation.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeAnimation.kt @@ -74,19 +74,23 @@ open class AnimationNodeAnimation( * Container for method_bind pointers for AnimationNodeAnimation */ private object __method_bind { - val getAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeAnimation".cstr.ptr, - "get_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_animation" } - } - val setAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeAnimation".cstr.ptr, - "set_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_animation" } - }} + val getAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeAnimation".cstr.ptr, + "get_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_animation" } + } + } + + val setAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeAnimation".cstr.ptr, + "set_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_animation" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlend2.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlend2.kt index 6ce48594..f4cb873d 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlend2.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlend2.kt @@ -74,19 +74,23 @@ open class AnimationNodeBlend2( * Container for method_bind pointers for AnimationNodeBlend2 */ private object __method_bind { - val isUsingSync: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlend2".cstr.ptr, - "is_using_sync".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_using_sync" } - } - val setUseSync: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlend2".cstr.ptr, - "set_use_sync".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_sync" } - }} + val isUsingSync: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlend2".cstr.ptr, + "is_using_sync".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_using_sync" } + } + } + + val setUseSync: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlend2".cstr.ptr, + "set_use_sync".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_sync" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlend3.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlend3.kt index 00dd47d5..f5846f61 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlend3.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlend3.kt @@ -74,19 +74,23 @@ open class AnimationNodeBlend3( * Container for method_bind pointers for AnimationNodeBlend3 */ private object __method_bind { - val isUsingSync: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlend3".cstr.ptr, - "is_using_sync".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_using_sync" } - } - val setUseSync: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlend3".cstr.ptr, - "set_use_sync".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_sync" } - }} + val isUsingSync: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlend3".cstr.ptr, + "is_using_sync".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_using_sync" } + } + } + + val setUseSync: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlend3".cstr.ptr, + "set_use_sync".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_sync" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlendSpace1D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlendSpace1D.kt index 0129d94d..aff788b7 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlendSpace1D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlendSpace1D.kt @@ -745,110 +745,140 @@ open class AnimationNodeBlendSpace1D( * Container for method_bind pointers for AnimationNodeBlendSpace1D */ private object __method_bind { - val addBlendPoint: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, - "add_blend_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_blend_point" } - } - val getBlendPointCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, - "get_blend_point_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_blend_point_count" } - } - val getBlendPointNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, - "get_blend_point_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_blend_point_node" } - } - val getBlendPointPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, - "get_blend_point_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_blend_point_position" } - } - val getMaxSpace: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, - "get_max_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_max_space" } - } - val getMinSpace: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, - "get_min_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_min_space" } - } - val getSnap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, - "get_snap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_snap" } - } - val getValueLabel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, - "get_value_label".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_value_label" } - } - val removeBlendPoint: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, - "remove_blend_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_blend_point" } - } - val setBlendPointNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, - "set_blend_point_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_blend_point_node" } - } - val setBlendPointPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, - "set_blend_point_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_blend_point_position" } - } - val setMaxSpace: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, - "set_max_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_max_space" } - } - val setMinSpace: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, - "set_min_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_min_space" } - } - val setSnap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, - "set_snap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_snap" } - } - val setValueLabel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, - "set_value_label".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_value_label" } - }} + val addBlendPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, + "add_blend_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_blend_point" } + } + } + + val getBlendPointCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, + "get_blend_point_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_blend_point_count" } + } + } + + val getBlendPointNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, + "get_blend_point_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_blend_point_node" } + } + } + + val getBlendPointPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, + "get_blend_point_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_blend_point_position" } + } + } + + val getMaxSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, + "get_max_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_max_space" } + } + } + + val getMinSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, + "get_min_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_min_space" } + } + } + + val getSnap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, + "get_snap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_snap" } + } + } + + val getValueLabel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, + "get_value_label".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_value_label" } + } + } + + val removeBlendPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, + "remove_blend_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_blend_point" } + } + } + + val setBlendPointNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, + "set_blend_point_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_blend_point_node" } + } + } + + val setBlendPointPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, + "set_blend_point_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_blend_point_position" } + } + } + + val setMaxSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, + "set_max_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_max_space" } + } + } + + val setMinSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, + "set_min_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_min_space" } + } + } + + val setSnap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, + "set_snap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_snap" } + } + } + + val setValueLabel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace1D".cstr.ptr, + "set_value_label".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_value_label" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlendSpace2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlendSpace2D.kt index 1f9106dc..7532e6cc 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlendSpace2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlendSpace2D.kt @@ -1516,180 +1516,230 @@ open class AnimationNodeBlendSpace2D( * Container for method_bind pointers for AnimationNodeBlendSpace2D */ private object __method_bind { - val addBlendPoint: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "add_blend_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_blend_point" } - } - val addTriangle: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "add_triangle".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_triangle" } - } - val getAutoTriangles: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "get_auto_triangles".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_auto_triangles" } - } - val getBlendMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "get_blend_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_blend_mode" } - } - val getBlendPointCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "get_blend_point_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_blend_point_count" } - } - val getBlendPointNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "get_blend_point_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_blend_point_node" } - } - val getBlendPointPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "get_blend_point_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_blend_point_position" } - } - val getMaxSpace: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "get_max_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_max_space" } - } - val getMinSpace: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "get_min_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_min_space" } - } - val getSnap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "get_snap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_snap" } - } - val getTriangleCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "get_triangle_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_triangle_count" } - } - val getTrianglePoint: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "get_triangle_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_triangle_point" } - } - val getXLabel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "get_x_label".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_x_label" } - } - val getYLabel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "get_y_label".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_y_label" } - } - val removeBlendPoint: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "remove_blend_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_blend_point" } - } - val removeTriangle: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "remove_triangle".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_triangle" } - } - val setAutoTriangles: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "set_auto_triangles".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_auto_triangles" } - } - val setBlendMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "set_blend_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_blend_mode" } - } - val setBlendPointNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "set_blend_point_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_blend_point_node" } - } - val setBlendPointPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "set_blend_point_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_blend_point_position" } - } - val setMaxSpace: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "set_max_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_max_space" } - } - val setMinSpace: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "set_min_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_min_space" } - } - val setSnap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "set_snap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_snap" } - } - val setXLabel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "set_x_label".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_x_label" } - } - val setYLabel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, - "set_y_label".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_y_label" } - }} + val addBlendPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "add_blend_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_blend_point" } + } + } + + val addTriangle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "add_triangle".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_triangle" } + } + } + + val getAutoTriangles: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "get_auto_triangles".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_auto_triangles" } + } + } + + val getBlendMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "get_blend_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_blend_mode" } + } + } + + val getBlendPointCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "get_blend_point_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_blend_point_count" } + } + } + + val getBlendPointNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "get_blend_point_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_blend_point_node" } + } + } + + val getBlendPointPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "get_blend_point_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_blend_point_position" } + } + } + + val getMaxSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "get_max_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_max_space" } + } + } + + val getMinSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "get_min_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_min_space" } + } + } + + val getSnap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "get_snap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_snap" } + } + } + + val getTriangleCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "get_triangle_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_triangle_count" } + } + } + + val getTrianglePoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "get_triangle_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_triangle_point" } + } + } + + val getXLabel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "get_x_label".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_x_label" } + } + } + + val getYLabel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "get_y_label".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_y_label" } + } + } + + val removeBlendPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "remove_blend_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_blend_point" } + } + } + + val removeTriangle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "remove_triangle".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_triangle" } + } + } + + val setAutoTriangles: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "set_auto_triangles".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_auto_triangles" } + } + } + + val setBlendMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "set_blend_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_blend_mode" } + } + } + + val setBlendPointNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "set_blend_point_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_blend_point_node" } + } + } + + val setBlendPointPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "set_blend_point_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_blend_point_position" } + } + } + + val setMaxSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "set_max_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_max_space" } + } + } + + val setMinSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "set_min_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_min_space" } + } + } + + val setSnap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "set_snap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_snap" } + } + } + + val setXLabel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "set_x_label".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_x_label" } + } + } + + val setYLabel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendSpace2D".cstr.ptr, + "set_y_label".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_y_label" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlendTree.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlendTree.kt index de7db978..ba031638 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlendTree.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeBlendTree.kt @@ -207,82 +207,104 @@ open class AnimationNodeBlendTree( * Container for method_bind pointers for AnimationNodeBlendTree */ private object __method_bind { - val addNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, - "add_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_node" } - } - val connectNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, - "connect_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method connect_node" } - } - val disconnectNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, - "disconnect_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method disconnect_node" } - } - val getGraphOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, - "get_graph_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_graph_offset" } - } - val getNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, - "get_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node" } - } - val getNodePosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, - "get_node_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_position" } - } - val hasNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, - "has_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_node" } - } - val removeNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, - "remove_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_node" } - } - val renameNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, - "rename_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rename_node" } - } - val setGraphOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, - "set_graph_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_graph_offset" } - } - val setNodePosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, - "set_node_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_node_position" } - }} + val addNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, + "add_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_node" } + } + } + + val connectNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, + "connect_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method connect_node" } + } + } + + val disconnectNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, + "disconnect_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method disconnect_node" } + } + } + + val getGraphOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, + "get_graph_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_graph_offset" } + } + } + + val getNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, + "get_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node" } + } + } + + val getNodePosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, + "get_node_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_position" } + } + } + + val hasNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, + "has_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_node" } + } + } + + val removeNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, + "remove_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_node" } + } + } + + val renameNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, + "rename_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rename_node" } + } + } + + val setGraphOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, + "set_graph_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_graph_offset" } + } + } + + val setNodePosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeBlendTree".cstr.ptr, + "set_node_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_node_position" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeOneShot.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeOneShot.kt index 4233f36d..9f75f087 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeOneShot.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeOneShot.kt @@ -237,103 +237,131 @@ open class AnimationNodeOneShot( * Container for method_bind pointers for AnimationNodeOneShot */ private object __method_bind { - val getAutorestartDelay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, - "get_autorestart_delay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_autorestart_delay" } - } - val getAutorestartRandomDelay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, - "get_autorestart_random_delay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_autorestart_random_delay" } - } - val getFadeinTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, - "get_fadein_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fadein_time" } - } - val getFadeoutTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, - "get_fadeout_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fadeout_time" } - } - val getMixMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, - "get_mix_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mix_mode" } - } - val hasAutorestart: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, - "has_autorestart".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_autorestart" } - } - val isUsingSync: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, - "is_using_sync".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_using_sync" } - } - val setAutorestart: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, - "set_autorestart".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_autorestart" } - } - val setAutorestartDelay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, - "set_autorestart_delay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_autorestart_delay" } - } - val setAutorestartRandomDelay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, - "set_autorestart_random_delay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_autorestart_random_delay" } - } - val setFadeinTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, - "set_fadein_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fadein_time" } - } - val setFadeoutTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, - "set_fadeout_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fadeout_time" } - } - val setMixMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, - "set_mix_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mix_mode" } - } - val setUseSync: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, - "set_use_sync".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_sync" } - }} + val getAutorestartDelay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, + "get_autorestart_delay".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_autorestart_delay" } + } + } + + val getAutorestartRandomDelay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, + "get_autorestart_random_delay".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_autorestart_random_delay" } + } + } + + val getFadeinTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, + "get_fadein_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fadein_time" } + } + } + + val getFadeoutTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, + "get_fadeout_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fadeout_time" } + } + } + + val getMixMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, + "get_mix_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mix_mode" } + } + } + + val hasAutorestart: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, + "has_autorestart".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_autorestart" } + } + } + + val isUsingSync: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, + "is_using_sync".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_using_sync" } + } + } + + val setAutorestart: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, + "set_autorestart".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_autorestart" } + } + } + + val setAutorestartDelay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, + "set_autorestart_delay".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_autorestart_delay" } + } + } + + val setAutorestartRandomDelay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, + "set_autorestart_random_delay".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_autorestart_random_delay" } + } + } + + val setFadeinTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, + "set_fadein_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fadein_time" } + } + } + + val setFadeoutTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, + "set_fadeout_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fadeout_time" } + } + } + + val setMixMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, + "set_mix_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mix_mode" } + } + } + + val setUseSync: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeOneShot".cstr.ptr, + "set_use_sync".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_sync" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeStateMachine.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeStateMachine.kt index 2238c140..afb5ef88 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeStateMachine.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeStateMachine.kt @@ -284,159 +284,203 @@ open class AnimationNodeStateMachine( * Container for method_bind pointers for AnimationNodeStateMachine */ private object __method_bind { - val addNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "add_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_node" } - } - val addTransition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "add_transition".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_transition" } - } - val getEndNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "get_end_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_end_node" } - } - val getGraphOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "get_graph_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_graph_offset" } - } - val getNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "get_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node" } - } - val getNodeName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "get_node_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_name" } - } - val getNodePosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "get_node_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_position" } - } - val getStartNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "get_start_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_start_node" } - } - val getTransition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "get_transition".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_transition" } - } - val getTransitionCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "get_transition_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_transition_count" } - } - val getTransitionFrom: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "get_transition_from".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_transition_from" } - } - val getTransitionTo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "get_transition_to".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_transition_to" } - } - val hasNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "has_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_node" } - } - val hasTransition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "has_transition".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_transition" } - } - val removeNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "remove_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_node" } - } - val removeTransition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "remove_transition".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_transition" } - } - val removeTransitionByIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "remove_transition_by_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_transition_by_index" } - } - val renameNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "rename_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rename_node" } - } - val setEndNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "set_end_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_end_node" } - } - val setGraphOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "set_graph_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_graph_offset" } - } - val setNodePosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "set_node_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_node_position" } - } - val setStartNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, - "set_start_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_start_node" } - }} + val addNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "add_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_node" } + } + } + + val addTransition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "add_transition".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_transition" } + } + } + + val getEndNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "get_end_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_end_node" } + } + } + + val getGraphOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "get_graph_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_graph_offset" } + } + } + + val getNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "get_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node" } + } + } + + val getNodeName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "get_node_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_name" } + } + } + + val getNodePosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "get_node_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_position" } + } + } + + val getStartNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "get_start_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_start_node" } + } + } + + val getTransition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "get_transition".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_transition" } + } + } + + val getTransitionCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "get_transition_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_transition_count" } + } + } + + val getTransitionFrom: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "get_transition_from".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_transition_from" } + } + } + + val getTransitionTo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "get_transition_to".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_transition_to" } + } + } + + val hasNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "has_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_node" } + } + } + + val hasTransition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "has_transition".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_transition" } + } + } + + val removeNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "remove_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_node" } + } + } + + val removeTransition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "remove_transition".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_transition" } + } + } + + val removeTransitionByIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "remove_transition_by_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_transition_by_index" } + } + } + + val renameNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "rename_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rename_node" } + } + } + + val setEndNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "set_end_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_end_node" } + } + } + + val setGraphOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "set_graph_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_graph_offset" } + } + } + + val setNodePosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "set_node_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_node_position" } + } + } + + val setStartNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachine".cstr.ptr, + "set_start_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_start_node" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeStateMachinePlayback.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeStateMachinePlayback.kt index 4bb5f42f..89e92452 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeStateMachinePlayback.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeStateMachinePlayback.kt @@ -103,47 +103,59 @@ open class AnimationNodeStateMachinePlayback( * Container for method_bind pointers for AnimationNodeStateMachinePlayback */ private object __method_bind { - val getCurrentNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachinePlayback".cstr.ptr, - "get_current_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_node" } - } - val getTravelPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachinePlayback".cstr.ptr, - "get_travel_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_travel_path" } - } - val isPlaying: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachinePlayback".cstr.ptr, - "is_playing".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_playing" } - } - val start: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachinePlayback".cstr.ptr, - "start".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method start" } - } - val stop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachinePlayback".cstr.ptr, - "stop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method stop" } - } - val travel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachinePlayback".cstr.ptr, - "travel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method travel" } - }} + val getCurrentNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachinePlayback".cstr.ptr, + "get_current_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_node" } + } + } + + val getTravelPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachinePlayback".cstr.ptr, + "get_travel_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_travel_path" } + } + } + + val isPlaying: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachinePlayback".cstr.ptr, + "is_playing".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_playing" } + } + } + + val start: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachinePlayback".cstr.ptr, + "start".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method start" } + } + } + + val stop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachinePlayback".cstr.ptr, + "stop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method stop" } + } + } + + val travel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachinePlayback".cstr.ptr, + "travel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method travel" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeStateMachineTransition.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeStateMachineTransition.kt index 09179d78..a648dca9 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeStateMachineTransition.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeStateMachineTransition.kt @@ -228,89 +228,113 @@ open class AnimationNodeStateMachineTransition( * Container for method_bind pointers for AnimationNodeStateMachineTransition */ private object __method_bind { - val getAdvanceCondition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, - "get_advance_condition".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_advance_condition" } - } - val getPriority: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, - "get_priority".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_priority" } - } - val getSwitchMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, - "get_switch_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_switch_mode" } - } - val getXfadeTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, - "get_xfade_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_xfade_time" } - } - val hasAutoAdvance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, - "has_auto_advance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_auto_advance" } - } - val isDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, - "is_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_disabled" } - } - val setAdvanceCondition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, - "set_advance_condition".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_advance_condition" } - } - val setAutoAdvance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, - "set_auto_advance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_auto_advance" } - } - val setDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, - "set_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_disabled" } - } - val setPriority: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, - "set_priority".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_priority" } - } - val setSwitchMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, - "set_switch_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_switch_mode" } - } - val setXfadeTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, - "set_xfade_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_xfade_time" } - }} + val getAdvanceCondition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, + "get_advance_condition".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_advance_condition" } + } + } + + val getPriority: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, + "get_priority".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_priority" } + } + } + + val getSwitchMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, + "get_switch_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_switch_mode" } + } + } + + val getXfadeTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, + "get_xfade_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_xfade_time" } + } + } + + val hasAutoAdvance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, + "has_auto_advance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_auto_advance" } + } + } + + val isDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, + "is_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_disabled" } + } + } + + val setAdvanceCondition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, + "set_advance_condition".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_advance_condition" } + } + } + + val setAutoAdvance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, + "set_auto_advance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_auto_advance" } + } + } + + val setDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, + "set_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_disabled" } + } + } + + val setPriority: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, + "set_priority".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_priority" } + } + } + + val setSwitchMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, + "set_switch_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_switch_mode" } + } + } + + val setXfadeTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeStateMachineTransition".cstr.ptr, + "set_xfade_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_xfade_time" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeTransition.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeTransition.kt index 25a32982..b3c5c7b8 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeTransition.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationNodeTransition.kt @@ -654,61 +654,77 @@ open class AnimationNodeTransition( * Container for method_bind pointers for AnimationNodeTransition */ private object __method_bind { - val getCrossFadeTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeTransition".cstr.ptr, - "get_cross_fade_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cross_fade_time" } - } - val getEnabledInputs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeTransition".cstr.ptr, - "get_enabled_inputs".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_enabled_inputs" } - } - val getInputCaption: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeTransition".cstr.ptr, - "get_input_caption".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_input_caption" } - } - val isInputSetAsAutoAdvance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeTransition".cstr.ptr, - "is_input_set_as_auto_advance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_input_set_as_auto_advance" } - } - val setCrossFadeTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeTransition".cstr.ptr, - "set_cross_fade_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cross_fade_time" } - } - val setEnabledInputs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeTransition".cstr.ptr, - "set_enabled_inputs".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_enabled_inputs" } - } - val setInputAsAutoAdvance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeTransition".cstr.ptr, - "set_input_as_auto_advance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_input_as_auto_advance" } - } - val setInputCaption: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeTransition".cstr.ptr, - "set_input_caption".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_input_caption" } - }} + val getCrossFadeTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeTransition".cstr.ptr, + "get_cross_fade_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cross_fade_time" } + } + } + + val getEnabledInputs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeTransition".cstr.ptr, + "get_enabled_inputs".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_enabled_inputs" } + } + } + + val getInputCaption: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeTransition".cstr.ptr, + "get_input_caption".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_input_caption" } + } + } + + val isInputSetAsAutoAdvance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeTransition".cstr.ptr, + "is_input_set_as_auto_advance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_input_set_as_auto_advance" } + } + } + + val setCrossFadeTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeTransition".cstr.ptr, + "set_cross_fade_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cross_fade_time" } + } + } + + val setEnabledInputs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeTransition".cstr.ptr, + "set_enabled_inputs".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_enabled_inputs" } + } + } + + val setInputAsAutoAdvance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeTransition".cstr.ptr, + "set_input_as_auto_advance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_input_as_auto_advance" } + } + } + + val setInputCaption: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationNodeTransition".cstr.ptr, + "set_input_caption".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_input_caption" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationPlayer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationPlayer.kt index edf2c17e..63ad32dc 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationPlayer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationPlayer.kt @@ -617,299 +617,384 @@ open class AnimationPlayer( * Container for method_bind pointers for AnimationPlayer */ private object __method_bind { - val addAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "add_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_animation" } - } - val advance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "advance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method advance" } - } - val animationGetNext: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "animation_get_next".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method animation_get_next" } - } - val animationSetNext: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "animation_set_next".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method animation_set_next" } - } - val clearCaches: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "clear_caches".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_caches" } - } - val clearQueue: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "clear_queue".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_queue" } - } - val findAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "find_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method find_animation" } - } - val getAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "get_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_animation" } - } - val getAnimationList: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "get_animation_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_animation_list" } - } - val getAnimationProcessMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "get_animation_process_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_animation_process_mode" } - } - val getAssignedAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "get_assigned_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_assigned_animation" } - } - val getAutoplay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "get_autoplay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_autoplay" } - } - val getBlendTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "get_blend_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_blend_time" } - } - val getCurrentAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "get_current_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_animation" } - } - val getCurrentAnimationLength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "get_current_animation_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_animation_length" } - } - val getCurrentAnimationPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "get_current_animation_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_animation_position" } - } - val getDefaultBlendTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "get_default_blend_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_default_blend_time" } - } - val getMethodCallMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "get_method_call_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_method_call_mode" } - } - val getPlayingSpeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "get_playing_speed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_playing_speed" } - } - val getQueue: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "get_queue".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_queue" } - } - val getRoot: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "get_root".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_root" } - } - val getSpeedScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "get_speed_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_speed_scale" } - } - val hasAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "has_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_animation" } - } - val isActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "is_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_active" } - } - val isPlaying: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "is_playing".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_playing" } - } - val play: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "play".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method play" } - } - val playBackwards: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "play_backwards".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method play_backwards" } - } - val queue: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "queue".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method queue" } - } - val removeAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "remove_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_animation" } - } - val renameAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "rename_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rename_animation" } - } - val seek: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "seek".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method seek" } - } - val setActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "set_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_active" } - } - val setAnimationProcessMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "set_animation_process_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_animation_process_mode" } - } - val setAssignedAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "set_assigned_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_assigned_animation" } - } - val setAutoplay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "set_autoplay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_autoplay" } - } - val setBlendTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "set_blend_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_blend_time" } - } - val setCurrentAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "set_current_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_current_animation" } - } - val setDefaultBlendTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "set_default_blend_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_default_blend_time" } - } - val setMethodCallMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "set_method_call_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_method_call_mode" } - } - val setRoot: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "set_root".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_root" } - } - val setSpeedScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "set_speed_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_speed_scale" } - } - val stop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, - "stop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method stop" } - }} + val addAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "add_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_animation" } + } + } + + val advance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "advance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method advance" } + } + } + + val animationGetNext: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "animation_get_next".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method animation_get_next" } + } + } + + val animationSetNext: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "animation_set_next".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method animation_set_next" } + } + } + + val clearCaches: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "clear_caches".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_caches" } + } + } + + val clearQueue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "clear_queue".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_queue" } + } + } + + val findAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "find_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method find_animation" } + } + } + + val getAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "get_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_animation" } + } + } + + val getAnimationList: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "get_animation_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_animation_list" } + } + } + + val getAnimationProcessMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "get_animation_process_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_animation_process_mode" } + } + } + + val getAssignedAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "get_assigned_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_assigned_animation" } + } + } + + val getAutoplay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "get_autoplay".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_autoplay" } + } + } + + val getBlendTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "get_blend_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_blend_time" } + } + } + + val getCurrentAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "get_current_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_animation" } + } + } + + val getCurrentAnimationLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "get_current_animation_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_animation_length" } + } + } + + val getCurrentAnimationPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "get_current_animation_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_animation_position" + } + } + } + + val getDefaultBlendTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "get_default_blend_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_default_blend_time" } + } + } + + val getMethodCallMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "get_method_call_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_method_call_mode" } + } + } + + val getPlayingSpeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "get_playing_speed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_playing_speed" } + } + } + + val getQueue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "get_queue".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_queue" } + } + } + + val getRoot: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "get_root".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_root" } + } + } + + val getSpeedScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "get_speed_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_speed_scale" } + } + } + + val hasAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "has_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_animation" } + } + } + + val isActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "is_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_active" } + } + } + + val isPlaying: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "is_playing".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_playing" } + } + } + + val play: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "play".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method play" } + } + } + + val playBackwards: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "play_backwards".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method play_backwards" } + } + } + + val queue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "queue".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method queue" } + } + } + + val removeAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "remove_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_animation" } + } + } + + val renameAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "rename_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rename_animation" } + } + } + + val seek: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "seek".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method seek" } + } + } + + val setActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "set_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_active" } + } + } + + val setAnimationProcessMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "set_animation_process_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_animation_process_mode" } + } + } + + val setAssignedAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "set_assigned_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_assigned_animation" } + } + } + + val setAutoplay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "set_autoplay".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_autoplay" } + } + } + + val setBlendTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "set_blend_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_blend_time" } + } + } + + val setCurrentAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "set_current_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_current_animation" } + } + } + + val setDefaultBlendTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "set_default_blend_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_default_blend_time" } + } + } + + val setMethodCallMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "set_method_call_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_method_call_mode" } + } + } + + val setRoot: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "set_root".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_root" } + } + } + + val setSpeedScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "set_speed_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_speed_scale" } + } + } + + val stop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationPlayer".cstr.ptr, + "stop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method stop" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationTree.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationTree.kt index 2cf6d240..acb05080 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationTree.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationTree.kt @@ -265,96 +265,122 @@ open class AnimationTree( * Container for method_bind pointers for AnimationTree */ private object __method_bind { - val advance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, - "advance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method advance" } - } - val getAnimationPlayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, - "get_animation_player".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_animation_player" } - } - val getProcessMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, - "get_process_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_process_mode" } - } - val getRootMotionTrack: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, - "get_root_motion_track".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_root_motion_track" } - } - val getRootMotionTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, - "get_root_motion_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_root_motion_transform" } - } - val getTreeRoot: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, - "get_tree_root".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tree_root" } - } - val isActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, - "is_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_active" } - } - val renameParameter: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, - "rename_parameter".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rename_parameter" } - } - val setActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, - "set_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_active" } - } - val setAnimationPlayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, - "set_animation_player".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_animation_player" } - } - val setProcessMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, - "set_process_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_process_mode" } - } - val setRootMotionTrack: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, - "set_root_motion_track".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_root_motion_track" } - } - val setTreeRoot: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, - "set_tree_root".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tree_root" } - }} + val advance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, + "advance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method advance" } + } + } + + val getAnimationPlayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, + "get_animation_player".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_animation_player" } + } + } + + val getProcessMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, + "get_process_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_process_mode" } + } + } + + val getRootMotionTrack: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, + "get_root_motion_track".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_root_motion_track" } + } + } + + val getRootMotionTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, + "get_root_motion_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_root_motion_transform" } + } + } + + val getTreeRoot: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, + "get_tree_root".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tree_root" } + } + } + + val isActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, + "is_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_active" } + } + } + + val renameParameter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, + "rename_parameter".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rename_parameter" } + } + } + + val setActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, + "set_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_active" } + } + } + + val setAnimationPlayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, + "set_animation_player".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_animation_player" } + } + } + + val setProcessMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, + "set_process_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_process_mode" } + } + } + + val setRootMotionTrack: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, + "set_root_motion_track".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_root_motion_track" } + } + } + + val setTreeRoot: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTree".cstr.ptr, + "set_tree_root".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tree_root" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationTreePlayer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationTreePlayer.kt index 8b4999f1..1e9d7e15 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AnimationTreePlayer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AnimationTreePlayer.kt @@ -834,468 +834,605 @@ open class AnimationTreePlayer( * Container for method_bind pointers for AnimationTreePlayer */ private object __method_bind { - val addNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "add_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_node" } - } - val advance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "advance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method advance" } - } - val animationNodeGetAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "animation_node_get_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method animation_node_get_animation" } - } - val animationNodeGetMasterAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "animation_node_get_master_animation".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method animation_node_get_master_animation" } - } - val animationNodeGetPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "animation_node_get_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method animation_node_get_position" } - } - val animationNodeSetAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "animation_node_set_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method animation_node_set_animation" } - } - val animationNodeSetFilterPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "animation_node_set_filter_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method animation_node_set_filter_path" } - } - val animationNodeSetMasterAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "animation_node_set_master_animation".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method animation_node_set_master_animation" } - } - val areNodesConnected: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "are_nodes_connected".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method are_nodes_connected" } - } - val blend2NodeGetAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "blend2_node_get_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method blend2_node_get_amount" } - } - val blend2NodeSetAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "blend2_node_set_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method blend2_node_set_amount" } - } - val blend2NodeSetFilterPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "blend2_node_set_filter_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method blend2_node_set_filter_path" } - } - val blend3NodeGetAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "blend3_node_get_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method blend3_node_get_amount" } - } - val blend3NodeSetAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "blend3_node_set_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method blend3_node_set_amount" } - } - val blend4NodeGetAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "blend4_node_get_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method blend4_node_get_amount" } - } - val blend4NodeSetAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "blend4_node_set_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method blend4_node_set_amount" } - } - val connectNodes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "connect_nodes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method connect_nodes" } - } - val disconnectNodes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "disconnect_nodes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method disconnect_nodes" } - } - val getAnimationProcessMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "get_animation_process_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_animation_process_mode" } - } - val getBasePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "get_base_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base_path" } - } - val getMasterPlayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "get_master_player".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_master_player" } - } - val getNodeList: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "get_node_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_list" } - } - val isActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "is_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_active" } - } - val mixNodeGetAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "mix_node_get_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mix_node_get_amount" } - } - val mixNodeSetAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "mix_node_set_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mix_node_set_amount" } - } - val nodeExists: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "node_exists".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method node_exists" } - } - val nodeGetInputCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "node_get_input_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method node_get_input_count" } - } - val nodeGetInputSource: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "node_get_input_source".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method node_get_input_source" } - } - val nodeGetPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "node_get_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method node_get_position" } - } - val nodeGetType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "node_get_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method node_get_type" } - } - val nodeRename: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "node_rename".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method node_rename" } - } - val nodeSetPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "node_set_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method node_set_position" } - } - val oneshotNodeGetAutorestartDelay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "oneshot_node_get_autorestart_delay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method oneshot_node_get_autorestart_delay" + val addNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "add_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_node" } } - } - val oneshotNodeGetAutorestartRandomDelay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "oneshot_node_get_autorestart_random_delay".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method oneshot_node_get_autorestart_random_delay" } - } - val oneshotNodeGetFadeinTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "oneshot_node_get_fadein_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method oneshot_node_get_fadein_time" } - } - val oneshotNodeGetFadeoutTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "oneshot_node_get_fadeout_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method oneshot_node_get_fadeout_time" } - } - val oneshotNodeHasAutorestart: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "oneshot_node_has_autorestart".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method oneshot_node_has_autorestart" } - } - val oneshotNodeIsActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "oneshot_node_is_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method oneshot_node_is_active" } - } - val oneshotNodeSetAutorestart: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "oneshot_node_set_autorestart".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method oneshot_node_set_autorestart" } - } - val oneshotNodeSetAutorestartDelay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "oneshot_node_set_autorestart_delay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method oneshot_node_set_autorestart_delay" + } + + val advance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "advance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method advance" } } - } - val oneshotNodeSetAutorestartRandomDelay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "oneshot_node_set_autorestart_random_delay".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method oneshot_node_set_autorestart_random_delay" } - } - val oneshotNodeSetFadeinTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "oneshot_node_set_fadein_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method oneshot_node_set_fadein_time" } - } - val oneshotNodeSetFadeoutTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "oneshot_node_set_fadeout_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method oneshot_node_set_fadeout_time" } - } - val oneshotNodeSetFilterPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "oneshot_node_set_filter_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method oneshot_node_set_filter_path" } - } - val oneshotNodeStart: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "oneshot_node_start".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method oneshot_node_start" } - } - val oneshotNodeStop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "oneshot_node_stop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method oneshot_node_stop" } - } - val recomputeCaches: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "recompute_caches".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method recompute_caches" } - } - val removeNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "remove_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_node" } - } - val reset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "reset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method reset" } - } - val setActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "set_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_active" } - } - val setAnimationProcessMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "set_animation_process_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_animation_process_mode" } - } - val setBasePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "set_base_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_base_path" } - } - val setMasterPlayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "set_master_player".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_master_player" } - } - val timescaleNodeGetScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "timescale_node_get_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method timescale_node_get_scale" } - } - val timescaleNodeSetScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "timescale_node_set_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method timescale_node_set_scale" } - } - val timeseekNodeSeek: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "timeseek_node_seek".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method timeseek_node_seek" } - } - val transitionNodeDeleteInput: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "transition_node_delete_input".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method transition_node_delete_input" } - } - val transitionNodeGetCurrent: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "transition_node_get_current".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method transition_node_get_current" } - } - val transitionNodeGetInputCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "transition_node_get_input_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method transition_node_get_input_count" } - } - val transitionNodeGetXfadeTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "transition_node_get_xfade_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method transition_node_get_xfade_time" } - } - val transitionNodeHasInputAutoAdvance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "transition_node_has_input_auto_advance".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method transition_node_has_input_auto_advance" } - } - val transitionNodeSetCurrent: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "transition_node_set_current".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method transition_node_set_current" } - } - val transitionNodeSetInputAutoAdvance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "transition_node_set_input_auto_advance".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method transition_node_set_input_auto_advance" } - } - val transitionNodeSetInputCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "transition_node_set_input_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method transition_node_set_input_count" } - } - val transitionNodeSetXfadeTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, - "transition_node_set_xfade_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method transition_node_set_xfade_time" } - }} + } + + val animationNodeGetAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "animation_node_get_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method animation_node_get_animation" } + } + } + + val animationNodeGetMasterAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "animation_node_get_master_animation".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method animation_node_get_master_animation" } + } + } + + val animationNodeGetPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "animation_node_get_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method animation_node_get_position" } + } + } + + val animationNodeSetAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "animation_node_set_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method animation_node_set_animation" } + } + } + + val animationNodeSetFilterPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "animation_node_set_filter_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method animation_node_set_filter_path" + } + } + } + + val animationNodeSetMasterAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "animation_node_set_master_animation".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method animation_node_set_master_animation" } + } + } + + val areNodesConnected: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "are_nodes_connected".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method are_nodes_connected" } + } + } + + val blend2NodeGetAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "blend2_node_get_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method blend2_node_get_amount" } + } + } + + val blend2NodeSetAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "blend2_node_set_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method blend2_node_set_amount" } + } + } + + val blend2NodeSetFilterPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "blend2_node_set_filter_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method blend2_node_set_filter_path" } + } + } + + val blend3NodeGetAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "blend3_node_get_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method blend3_node_get_amount" } + } + } + + val blend3NodeSetAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "blend3_node_set_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method blend3_node_set_amount" } + } + } + + val blend4NodeGetAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "blend4_node_get_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method blend4_node_get_amount" } + } + } + + val blend4NodeSetAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "blend4_node_set_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method blend4_node_set_amount" } + } + } + + val connectNodes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "connect_nodes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method connect_nodes" } + } + } + + val disconnectNodes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "disconnect_nodes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method disconnect_nodes" } + } + } + + val getAnimationProcessMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "get_animation_process_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_animation_process_mode" } + } + } + + val getBasePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "get_base_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base_path" } + } + } + + val getMasterPlayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "get_master_player".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_master_player" } + } + } + + val getNodeList: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "get_node_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_list" } + } + } + + val isActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "is_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_active" } + } + } + + val mixNodeGetAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "mix_node_get_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mix_node_get_amount" } + } + } + + val mixNodeSetAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "mix_node_set_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mix_node_set_amount" } + } + } + + val nodeExists: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "node_exists".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method node_exists" } + } + } + + val nodeGetInputCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "node_get_input_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method node_get_input_count" } + } + } + + val nodeGetInputSource: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "node_get_input_source".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method node_get_input_source" } + } + } + + val nodeGetPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "node_get_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method node_get_position" } + } + } + + val nodeGetType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "node_get_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method node_get_type" } + } + } + + val nodeRename: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "node_rename".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method node_rename" } + } + } + + val nodeSetPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "node_set_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method node_set_position" } + } + } + + val oneshotNodeGetAutorestartDelay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "oneshot_node_get_autorestart_delay".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method oneshot_node_get_autorestart_delay" } + } + } + + val oneshotNodeGetAutorestartRandomDelay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "oneshot_node_get_autorestart_random_delay".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method oneshot_node_get_autorestart_random_delay" } + } + } + + val oneshotNodeGetFadeinTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "oneshot_node_get_fadein_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method oneshot_node_get_fadein_time" } + } + } + + val oneshotNodeGetFadeoutTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "oneshot_node_get_fadeout_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method oneshot_node_get_fadeout_time" + } + } + } + + val oneshotNodeHasAutorestart: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "oneshot_node_has_autorestart".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method oneshot_node_has_autorestart" } + } + } + + val oneshotNodeIsActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "oneshot_node_is_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method oneshot_node_is_active" } + } + } + + val oneshotNodeSetAutorestart: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "oneshot_node_set_autorestart".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method oneshot_node_set_autorestart" } + } + } + + val oneshotNodeSetAutorestartDelay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "oneshot_node_set_autorestart_delay".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method oneshot_node_set_autorestart_delay" } + } + } + + val oneshotNodeSetAutorestartRandomDelay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "oneshot_node_set_autorestart_random_delay".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method oneshot_node_set_autorestart_random_delay" } + } + } + + val oneshotNodeSetFadeinTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "oneshot_node_set_fadein_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method oneshot_node_set_fadein_time" } + } + } + + val oneshotNodeSetFadeoutTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "oneshot_node_set_fadeout_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method oneshot_node_set_fadeout_time" + } + } + } + + val oneshotNodeSetFilterPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "oneshot_node_set_filter_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method oneshot_node_set_filter_path" } + } + } + + val oneshotNodeStart: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "oneshot_node_start".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method oneshot_node_start" } + } + } + + val oneshotNodeStop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "oneshot_node_stop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method oneshot_node_stop" } + } + } + + val recomputeCaches: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "recompute_caches".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method recompute_caches" } + } + } + + val removeNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "remove_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_node" } + } + } + + val reset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "reset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method reset" } + } + } + + val setActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "set_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_active" } + } + } + + val setAnimationProcessMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "set_animation_process_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_animation_process_mode" } + } + } + + val setBasePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "set_base_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_base_path" } + } + } + + val setMasterPlayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "set_master_player".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_master_player" } + } + } + + val timescaleNodeGetScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "timescale_node_get_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method timescale_node_get_scale" } + } + } + + val timescaleNodeSetScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "timescale_node_set_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method timescale_node_set_scale" } + } + } + + val timeseekNodeSeek: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "timeseek_node_seek".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method timeseek_node_seek" } + } + } + + val transitionNodeDeleteInput: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "transition_node_delete_input".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method transition_node_delete_input" } + } + } + + val transitionNodeGetCurrent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "transition_node_get_current".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method transition_node_get_current" } + } + } + + val transitionNodeGetInputCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "transition_node_get_input_count".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method transition_node_get_input_count" } + } + } + + val transitionNodeGetXfadeTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "transition_node_get_xfade_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method transition_node_get_xfade_time" + } + } + } + + val transitionNodeHasInputAutoAdvance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "transition_node_has_input_auto_advance".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method transition_node_has_input_auto_advance" } + } + } + + val transitionNodeSetCurrent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "transition_node_set_current".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method transition_node_set_current" } + } + } + + val transitionNodeSetInputAutoAdvance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "transition_node_set_input_auto_advance".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method transition_node_set_input_auto_advance" } + } + } + + val transitionNodeSetInputCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "transition_node_set_input_count".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method transition_node_set_input_count" } + } + } + + val transitionNodeSetXfadeTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AnimationTreePlayer".cstr.ptr, + "transition_node_set_xfade_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method transition_node_set_xfade_time" + } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Area.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Area.kt index ac90fbd1..4e357245 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Area.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Area.kt @@ -698,269 +698,357 @@ open class Area( * Container for method_bind pointers for Area */ private object __method_bind { - val getAngularDamp: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "get_angular_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_angular_damp" } - } - val getAudioBus: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "get_audio_bus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_audio_bus" } - } - val getCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "get_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_layer" } - } - val getCollisionLayerBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "get_collision_layer_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_layer_bit" } - } - val getCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "get_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } - } - val getCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "get_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } - } - val getGravity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "get_gravity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gravity" } - } - val getGravityDistanceScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "get_gravity_distance_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gravity_distance_scale" } - } - val getGravityVector: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "get_gravity_vector".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gravity_vector" } - } - val getLinearDamp: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "get_linear_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_linear_damp" } - } - val getOverlappingAreas: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "get_overlapping_areas".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_overlapping_areas" } - } - val getOverlappingBodies: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "get_overlapping_bodies".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_overlapping_bodies" } - } - val getPriority: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "get_priority".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_priority" } - } - val getReverbAmount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "get_reverb_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_reverb_amount" } - } - val getReverbBus: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "get_reverb_bus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_reverb_bus" } - } - val getReverbUniformity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "get_reverb_uniformity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_reverb_uniformity" } - } - val getSpaceOverrideMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "get_space_override_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_space_override_mode" } - } - val isGravityAPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "is_gravity_a_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_gravity_a_point" } - } - val isMonitorable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "is_monitorable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_monitorable" } - } - val isMonitoring: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "is_monitoring".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_monitoring" } - } - val isOverridingAudioBus: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "is_overriding_audio_bus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_overriding_audio_bus" } - } - val isUsingReverbBus: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "is_using_reverb_bus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_using_reverb_bus" } - } - val overlapsArea: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "overlaps_area".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method overlaps_area" } - } - val overlapsBody: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "overlaps_body".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method overlaps_body" } - } - val setAngularDamp: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_angular_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_angular_damp" } - } - val setAudioBus: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_audio_bus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_audio_bus" } - } - val setAudioBusOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_audio_bus_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_audio_bus_override" } - } - val setCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_layer" } - } - val setCollisionLayerBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_collision_layer_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_layer_bit" } - } - val setCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } - } - val setCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } - } - val setGravity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_gravity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_gravity" } - } - val setGravityDistanceScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_gravity_distance_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_gravity_distance_scale" } - } - val setGravityIsPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_gravity_is_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_gravity_is_point" } - } - val setGravityVector: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_gravity_vector".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_gravity_vector" } - } - val setLinearDamp: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_linear_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_linear_damp" } - } - val setMonitorable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_monitorable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_monitorable" } - } - val setMonitoring: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_monitoring".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_monitoring" } - } - val setPriority: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_priority".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_priority" } - } - val setReverbAmount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_reverb_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_reverb_amount" } - } - val setReverbBus: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_reverb_bus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_reverb_bus" } - } - val setReverbUniformity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_reverb_uniformity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_reverb_uniformity" } - } - val setSpaceOverrideMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_space_override_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_space_override_mode" } - } - val setUseReverbBus: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, - "set_use_reverb_bus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_reverb_bus" } - }} + val getAngularDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "get_angular_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_angular_damp" } + } + } + + val getAudioBus: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "get_audio_bus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_audio_bus" } + } + } + + val getCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "get_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_layer" } + } + } + + val getCollisionLayerBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "get_collision_layer_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_layer_bit" } + } + } + + val getCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "get_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } + } + } + + val getCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "get_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } + } + } + + val getGravity: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "get_gravity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gravity" } + } + } + + val getGravityDistanceScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "get_gravity_distance_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gravity_distance_scale" } + } + } + + val getGravityVector: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "get_gravity_vector".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gravity_vector" } + } + } + + val getLinearDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "get_linear_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_linear_damp" } + } + } + + val getOverlappingAreas: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "get_overlapping_areas".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_overlapping_areas" } + } + } + + val getOverlappingBodies: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "get_overlapping_bodies".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_overlapping_bodies" } + } + } + + val getPriority: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "get_priority".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_priority" } + } + } + + val getReverbAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "get_reverb_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_reverb_amount" } + } + } + + val getReverbBus: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "get_reverb_bus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_reverb_bus" } + } + } + + val getReverbUniformity: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "get_reverb_uniformity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_reverb_uniformity" } + } + } + + val getSpaceOverrideMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "get_space_override_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_space_override_mode" } + } + } + + val isGravityAPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "is_gravity_a_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_gravity_a_point" } + } + } + + val isMonitorable: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "is_monitorable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_monitorable" } + } + } + + val isMonitoring: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "is_monitoring".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_monitoring" } + } + } + + val isOverridingAudioBus: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "is_overriding_audio_bus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_overriding_audio_bus" } + } + } + + val isUsingReverbBus: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "is_using_reverb_bus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_using_reverb_bus" } + } + } + + val overlapsArea: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "overlaps_area".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method overlaps_area" } + } + } + + val overlapsBody: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "overlaps_body".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method overlaps_body" } + } + } + + val setAngularDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_angular_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_angular_damp" } + } + } + + val setAudioBus: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_audio_bus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_audio_bus" } + } + } + + val setAudioBusOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_audio_bus_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_audio_bus_override" } + } + } + + val setCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_layer" } + } + } + + val setCollisionLayerBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_collision_layer_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_layer_bit" } + } + } + + val setCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } + } + } + + val setCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } + } + } + + val setGravity: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_gravity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_gravity" } + } + } + + val setGravityDistanceScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_gravity_distance_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_gravity_distance_scale" } + } + } + + val setGravityIsPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_gravity_is_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_gravity_is_point" } + } + } + + val setGravityVector: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_gravity_vector".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_gravity_vector" } + } + } + + val setLinearDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_linear_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_linear_damp" } + } + } + + val setMonitorable: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_monitorable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_monitorable" } + } + } + + val setMonitoring: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_monitoring".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_monitoring" } + } + } + + val setPriority: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_priority".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_priority" } + } + } + + val setReverbAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_reverb_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_reverb_amount" } + } + } + + val setReverbBus: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_reverb_bus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_reverb_bus" } + } + } + + val setReverbUniformity: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_reverb_uniformity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_reverb_uniformity" } + } + } + + val setSpaceOverrideMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_space_override_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_space_override_mode" } + } + } + + val setUseReverbBus: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area".cstr.ptr, + "set_use_reverb_bus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_reverb_bus" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Area2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Area2D.kt index 3f4bc4fb..c5124ac6 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Area2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Area2D.kt @@ -597,221 +597,293 @@ open class Area2D( * Container for method_bind pointers for Area2D */ private object __method_bind { - val getAngularDamp: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "get_angular_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_angular_damp" } - } - val getAudioBusName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "get_audio_bus_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_audio_bus_name" } - } - val getCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "get_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_layer" } - } - val getCollisionLayerBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "get_collision_layer_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_layer_bit" } - } - val getCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "get_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } - } - val getCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "get_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } - } - val getGravity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "get_gravity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gravity" } - } - val getGravityDistanceScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "get_gravity_distance_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gravity_distance_scale" } - } - val getGravityVector: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "get_gravity_vector".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gravity_vector" } - } - val getLinearDamp: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "get_linear_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_linear_damp" } - } - val getOverlappingAreas: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "get_overlapping_areas".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_overlapping_areas" } - } - val getOverlappingBodies: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "get_overlapping_bodies".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_overlapping_bodies" } - } - val getPriority: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "get_priority".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_priority" } - } - val getSpaceOverrideMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "get_space_override_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_space_override_mode" } - } - val isGravityAPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "is_gravity_a_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_gravity_a_point" } - } - val isMonitorable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "is_monitorable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_monitorable" } - } - val isMonitoring: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "is_monitoring".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_monitoring" } - } - val isOverridingAudioBus: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "is_overriding_audio_bus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_overriding_audio_bus" } - } - val overlapsArea: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "overlaps_area".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method overlaps_area" } - } - val overlapsBody: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "overlaps_body".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method overlaps_body" } - } - val setAngularDamp: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "set_angular_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_angular_damp" } - } - val setAudioBusName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "set_audio_bus_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_audio_bus_name" } - } - val setAudioBusOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "set_audio_bus_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_audio_bus_override" } - } - val setCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "set_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_layer" } - } - val setCollisionLayerBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "set_collision_layer_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_layer_bit" } - } - val setCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "set_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } - } - val setCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "set_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } - } - val setGravity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "set_gravity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_gravity" } - } - val setGravityDistanceScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "set_gravity_distance_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_gravity_distance_scale" } - } - val setGravityIsPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "set_gravity_is_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_gravity_is_point" } - } - val setGravityVector: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "set_gravity_vector".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_gravity_vector" } - } - val setLinearDamp: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "set_linear_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_linear_damp" } - } - val setMonitorable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "set_monitorable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_monitorable" } - } - val setMonitoring: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "set_monitoring".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_monitoring" } - } - val setPriority: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "set_priority".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_priority" } - } - val setSpaceOverrideMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, - "set_space_override_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_space_override_mode" } - }} + val getAngularDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "get_angular_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_angular_damp" } + } + } + + val getAudioBusName: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "get_audio_bus_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_audio_bus_name" } + } + } + + val getCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "get_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_layer" } + } + } + + val getCollisionLayerBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "get_collision_layer_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_layer_bit" } + } + } + + val getCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "get_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } + } + } + + val getCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "get_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } + } + } + + val getGravity: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "get_gravity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gravity" } + } + } + + val getGravityDistanceScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "get_gravity_distance_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gravity_distance_scale" } + } + } + + val getGravityVector: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "get_gravity_vector".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gravity_vector" } + } + } + + val getLinearDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "get_linear_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_linear_damp" } + } + } + + val getOverlappingAreas: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "get_overlapping_areas".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_overlapping_areas" } + } + } + + val getOverlappingBodies: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "get_overlapping_bodies".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_overlapping_bodies" } + } + } + + val getPriority: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "get_priority".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_priority" } + } + } + + val getSpaceOverrideMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "get_space_override_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_space_override_mode" } + } + } + + val isGravityAPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "is_gravity_a_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_gravity_a_point" } + } + } + + val isMonitorable: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "is_monitorable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_monitorable" } + } + } + + val isMonitoring: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "is_monitoring".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_monitoring" } + } + } + + val isOverridingAudioBus: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "is_overriding_audio_bus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_overriding_audio_bus" } + } + } + + val overlapsArea: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "overlaps_area".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method overlaps_area" } + } + } + + val overlapsBody: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "overlaps_body".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method overlaps_body" } + } + } + + val setAngularDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "set_angular_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_angular_damp" } + } + } + + val setAudioBusName: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "set_audio_bus_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_audio_bus_name" } + } + } + + val setAudioBusOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "set_audio_bus_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_audio_bus_override" } + } + } + + val setCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "set_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_layer" } + } + } + + val setCollisionLayerBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "set_collision_layer_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_layer_bit" } + } + } + + val setCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "set_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } + } + } + + val setCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "set_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } + } + } + + val setGravity: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "set_gravity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_gravity" } + } + } + + val setGravityDistanceScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "set_gravity_distance_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_gravity_distance_scale" } + } + } + + val setGravityIsPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "set_gravity_is_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_gravity_is_point" } + } + } + + val setGravityVector: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "set_gravity_vector".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_gravity_vector" } + } + } + + val setLinearDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "set_linear_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_linear_damp" } + } + } + + val setMonitorable: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "set_monitorable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_monitorable" } + } + } + + val setMonitoring: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "set_monitoring".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_monitoring" } + } + } + + val setPriority: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "set_priority".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_priority" } + } + } + + val setSpaceOverrideMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Area2D".cstr.ptr, + "set_space_override_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_space_override_mode" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ArrayMesh.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ArrayMesh.kt index c1b4d8fd..a127d4cc 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ArrayMesh.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ArrayMesh.kt @@ -351,125 +351,185 @@ open class ArrayMesh( * Container for method_bind pointers for ArrayMesh */ private object __method_bind { - val addBlendShape: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "add_blend_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_blend_shape" } - } - val addSurfaceFromArrays: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "add_surface_from_arrays".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_surface_from_arrays" } - } - val clearBlendShapes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "clear_blend_shapes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_blend_shapes" } - } - val getBlendShapeCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "get_blend_shape_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_blend_shape_count" } - } - val getBlendShapeMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "get_blend_shape_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_blend_shape_mode" } - } - val getBlendShapeName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "get_blend_shape_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_blend_shape_name" } - } - val getCustomAabb: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "get_custom_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_custom_aabb" } - } - val lightmapUnwrap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "lightmap_unwrap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method lightmap_unwrap" } - } - val regenNormalmaps: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "regen_normalmaps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method regen_normalmaps" } - } - val setBlendShapeMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "set_blend_shape_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_blend_shape_mode" } - } - val setCustomAabb: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "set_custom_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_custom_aabb" } - } - val surfaceFindByName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "surface_find_by_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method surface_find_by_name" } - } - val surfaceGetArrayIndexLen: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "surface_get_array_index_len".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method surface_get_array_index_len" } - } - val surfaceGetArrayLen: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "surface_get_array_len".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method surface_get_array_len" } - } - val surfaceGetFormat: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "surface_get_format".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method surface_get_format" } - } - val surfaceGetName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "surface_get_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method surface_get_name" } - } - val surfaceGetPrimitiveType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "surface_get_primitive_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method surface_get_primitive_type" } - } - val surfaceRemove: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "surface_remove".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method surface_remove" } - } - val surfaceSetName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "surface_set_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method surface_set_name" } - } - val surfaceUpdateRegion: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, - "surface_update_region".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method surface_update_region" } - }} + val addBlendShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "add_blend_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_blend_shape" } + } + } + + val addSurfaceFromArrays: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "add_surface_from_arrays".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_surface_from_arrays" } + } + } + + val clearBlendShapes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "clear_blend_shapes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_blend_shapes" } + } + } + + val getBlendShapeCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "get_blend_shape_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_blend_shape_count" } + } + } + + val getBlendShapeMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "get_blend_shape_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_blend_shape_mode" } + } + } + + val getBlendShapeName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "get_blend_shape_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_blend_shape_name" } + } + } + + val getCustomAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "get_custom_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_custom_aabb" } + } + } + + val lightmapUnwrap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "lightmap_unwrap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method lightmap_unwrap" } + } + } + + val regenNormalmaps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "regen_normalmaps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method regen_normalmaps" } + } + } + + val setBlendShapeMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "set_blend_shape_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_blend_shape_mode" } + } + } + + val setCustomAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "set_custom_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_custom_aabb" } + } + } + + val surfaceFindByName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "surface_find_by_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method surface_find_by_name" } + } + } + + val surfaceGetArrayIndexLen: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "surface_get_array_index_len".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method surface_get_array_index_len" } + } + } + + val surfaceGetArrayLen: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "surface_get_array_len".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method surface_get_array_len" } + } + } + + val surfaceGetFormat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "surface_get_format".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method surface_get_format" } + } + } + + val surfaceGetName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "surface_get_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method surface_get_name" } + } + } + + val surfaceGetPrimitiveType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "surface_get_primitive_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method surface_get_primitive_type" } + } + } + + val surfaceRemove: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "surface_remove".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method surface_remove" } + } + } + + val surfaceSetName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "surface_set_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method surface_set_name" } + } + } + + val surfaceUpdateRegion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ArrayMesh".cstr.ptr, + "surface_update_region".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method surface_update_region" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AtlasTexture.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AtlasTexture.kt index e60cf14a..6d5ea293 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AtlasTexture.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AtlasTexture.kt @@ -172,61 +172,77 @@ open class AtlasTexture( * Container for method_bind pointers for AtlasTexture */ private object __method_bind { - val getAtlas: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AtlasTexture".cstr.ptr, - "get_atlas".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_atlas" } - } - val getMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AtlasTexture".cstr.ptr, - "get_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_margin" } - } - val getRegion: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AtlasTexture".cstr.ptr, - "get_region".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_region" } - } - val hasFilterClip: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AtlasTexture".cstr.ptr, - "has_filter_clip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_filter_clip" } - } - val setAtlas: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AtlasTexture".cstr.ptr, - "set_atlas".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_atlas" } - } - val setFilterClip: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AtlasTexture".cstr.ptr, - "set_filter_clip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_filter_clip" } - } - val setMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AtlasTexture".cstr.ptr, - "set_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_margin" } - } - val setRegion: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AtlasTexture".cstr.ptr, - "set_region".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_region" } - }} + val getAtlas: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AtlasTexture".cstr.ptr, + "get_atlas".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_atlas" } + } + } + + val getMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AtlasTexture".cstr.ptr, + "get_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_margin" } + } + } + + val getRegion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AtlasTexture".cstr.ptr, + "get_region".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_region" } + } + } + + val hasFilterClip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AtlasTexture".cstr.ptr, + "has_filter_clip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_filter_clip" } + } + } + + val setAtlas: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AtlasTexture".cstr.ptr, + "set_atlas".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_atlas" } + } + } + + val setFilterClip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AtlasTexture".cstr.ptr, + "set_filter_clip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_filter_clip" } + } + } + + val setMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AtlasTexture".cstr.ptr, + "set_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_margin" } + } + } + + val setRegion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AtlasTexture".cstr.ptr, + "set_region".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_region" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectAmplify.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectAmplify.kt index c751079f..5b6f77eb 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectAmplify.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectAmplify.kt @@ -74,19 +74,23 @@ open class AudioEffectAmplify( * Container for method_bind pointers for AudioEffectAmplify */ private object __method_bind { - val getVolumeDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectAmplify".cstr.ptr, - "get_volume_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_volume_db" } - } - val setVolumeDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectAmplify".cstr.ptr, - "set_volume_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_volume_db" } - }} + val getVolumeDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectAmplify".cstr.ptr, + "get_volume_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_volume_db" } + } + } + + val setVolumeDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectAmplify".cstr.ptr, + "set_volume_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_volume_db" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectChorus.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectChorus.kt index 522ef679..0b5ce305 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectChorus.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectChorus.kt @@ -437,131 +437,167 @@ open class AudioEffectChorus( * Container for method_bind pointers for AudioEffectChorus */ private object __method_bind { - val getDry: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, - "get_dry".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_dry" } - } - val getVoiceCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, - "get_voice_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_voice_count" } - } - val getVoiceCutoffHz: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, - "get_voice_cutoff_hz".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_voice_cutoff_hz" } - } - val getVoiceDelayMs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, - "get_voice_delay_ms".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_voice_delay_ms" } - } - val getVoiceDepthMs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, - "get_voice_depth_ms".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_voice_depth_ms" } - } - val getVoiceLevelDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, - "get_voice_level_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_voice_level_db" } - } - val getVoicePan: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, - "get_voice_pan".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_voice_pan" } - } - val getVoiceRateHz: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, - "get_voice_rate_hz".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_voice_rate_hz" } - } - val getWet: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, - "get_wet".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_wet" } - } - val setDry: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, - "set_dry".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_dry" } - } - val setVoiceCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, - "set_voice_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_voice_count" } - } - val setVoiceCutoffHz: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, - "set_voice_cutoff_hz".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_voice_cutoff_hz" } - } - val setVoiceDelayMs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, - "set_voice_delay_ms".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_voice_delay_ms" } - } - val setVoiceDepthMs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, - "set_voice_depth_ms".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_voice_depth_ms" } - } - val setVoiceLevelDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, - "set_voice_level_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_voice_level_db" } - } - val setVoicePan: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, - "set_voice_pan".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_voice_pan" } - } - val setVoiceRateHz: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, - "set_voice_rate_hz".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_voice_rate_hz" } - } - val setWet: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, - "set_wet".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_wet" } - }} + val getDry: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, + "get_dry".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_dry" } + } + } + + val getVoiceCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, + "get_voice_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_voice_count" } + } + } + + val getVoiceCutoffHz: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, + "get_voice_cutoff_hz".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_voice_cutoff_hz" } + } + } + + val getVoiceDelayMs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, + "get_voice_delay_ms".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_voice_delay_ms" } + } + } + + val getVoiceDepthMs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, + "get_voice_depth_ms".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_voice_depth_ms" } + } + } + + val getVoiceLevelDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, + "get_voice_level_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_voice_level_db" } + } + } + + val getVoicePan: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, + "get_voice_pan".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_voice_pan" } + } + } + + val getVoiceRateHz: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, + "get_voice_rate_hz".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_voice_rate_hz" } + } + } + + val getWet: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, + "get_wet".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_wet" } + } + } + + val setDry: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, + "set_dry".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_dry" } + } + } + + val setVoiceCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, + "set_voice_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_voice_count" } + } + } + + val setVoiceCutoffHz: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, + "set_voice_cutoff_hz".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_voice_cutoff_hz" } + } + } + + val setVoiceDelayMs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, + "set_voice_delay_ms".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_voice_delay_ms" } + } + } + + val setVoiceDepthMs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, + "set_voice_depth_ms".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_voice_depth_ms" } + } + } + + val setVoiceLevelDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, + "set_voice_level_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_voice_level_db" } + } + } + + val setVoicePan: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, + "set_voice_pan".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_voice_pan" } + } + } + + val setVoiceRateHz: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, + "set_voice_rate_hz".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_voice_rate_hz" } + } + } + + val setWet: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectChorus".cstr.ptr, + "set_wet".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_wet" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectCompressor.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectCompressor.kt index 87b51694..c5999c3e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectCompressor.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectCompressor.kt @@ -225,103 +225,131 @@ open class AudioEffectCompressor( * Container for method_bind pointers for AudioEffectCompressor */ private object __method_bind { - val getAttackUs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, - "get_attack_us".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_attack_us" } - } - val getGain: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, - "get_gain".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gain" } - } - val getMix: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, - "get_mix".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mix" } - } - val getRatio: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, - "get_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ratio" } - } - val getReleaseMs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, - "get_release_ms".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_release_ms" } - } - val getSidechain: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, - "get_sidechain".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sidechain" } - } - val getThreshold: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, - "get_threshold".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_threshold" } - } - val setAttackUs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, - "set_attack_us".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_attack_us" } - } - val setGain: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, - "set_gain".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_gain" } - } - val setMix: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, - "set_mix".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mix" } - } - val setRatio: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, - "set_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ratio" } - } - val setReleaseMs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, - "set_release_ms".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_release_ms" } - } - val setSidechain: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, - "set_sidechain".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sidechain" } - } - val setThreshold: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, - "set_threshold".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_threshold" } - }} + val getAttackUs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, + "get_attack_us".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_attack_us" } + } + } + + val getGain: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, + "get_gain".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gain" } + } + } + + val getMix: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, + "get_mix".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mix" } + } + } + + val getRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, + "get_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ratio" } + } + } + + val getReleaseMs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, + "get_release_ms".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_release_ms" } + } + } + + val getSidechain: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, + "get_sidechain".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sidechain" } + } + } + + val getThreshold: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, + "get_threshold".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_threshold" } + } + } + + val setAttackUs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, + "set_attack_us".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_attack_us" } + } + } + + val setGain: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, + "set_gain".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_gain" } + } + } + + val setMix: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, + "set_mix".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mix" } + } + } + + val setRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, + "set_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ratio" } + } + } + + val setReleaseMs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, + "set_release_ms".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_release_ms" } + } + } + + val setSidechain: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, + "set_sidechain".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sidechain" } + } + } + + val setThreshold: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectCompressor".cstr.ptr, + "set_threshold".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_threshold" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectDelay.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectDelay.kt index 27f15181..7f086a57 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectDelay.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectDelay.kt @@ -375,187 +375,239 @@ open class AudioEffectDelay( * Container for method_bind pointers for AudioEffectDelay */ private object __method_bind { - val getDry: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "get_dry".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_dry" } - } - val getFeedbackDelayMs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "get_feedback_delay_ms".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_feedback_delay_ms" } - } - val getFeedbackLevelDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "get_feedback_level_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_feedback_level_db" } - } - val getFeedbackLowpass: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "get_feedback_lowpass".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_feedback_lowpass" } - } - val getTap1DelayMs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "get_tap1_delay_ms".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tap1_delay_ms" } - } - val getTap1LevelDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "get_tap1_level_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tap1_level_db" } - } - val getTap1Pan: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "get_tap1_pan".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tap1_pan" } - } - val getTap2DelayMs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "get_tap2_delay_ms".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tap2_delay_ms" } - } - val getTap2LevelDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "get_tap2_level_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tap2_level_db" } - } - val getTap2Pan: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "get_tap2_pan".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tap2_pan" } - } - val isFeedbackActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "is_feedback_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_feedback_active" } - } - val isTap1Active: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "is_tap1_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_tap1_active" } - } - val isTap2Active: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "is_tap2_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_tap2_active" } - } - val setDry: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "set_dry".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_dry" } - } - val setFeedbackActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "set_feedback_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_feedback_active" } - } - val setFeedbackDelayMs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "set_feedback_delay_ms".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_feedback_delay_ms" } - } - val setFeedbackLevelDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "set_feedback_level_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_feedback_level_db" } - } - val setFeedbackLowpass: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "set_feedback_lowpass".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_feedback_lowpass" } - } - val setTap1Active: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "set_tap1_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tap1_active" } - } - val setTap1DelayMs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "set_tap1_delay_ms".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tap1_delay_ms" } - } - val setTap1LevelDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "set_tap1_level_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tap1_level_db" } - } - val setTap1Pan: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "set_tap1_pan".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tap1_pan" } - } - val setTap2Active: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "set_tap2_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tap2_active" } - } - val setTap2DelayMs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "set_tap2_delay_ms".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tap2_delay_ms" } - } - val setTap2LevelDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "set_tap2_level_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tap2_level_db" } - } - val setTap2Pan: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, - "set_tap2_pan".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tap2_pan" } - }} + val getDry: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "get_dry".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_dry" } + } + } + + val getFeedbackDelayMs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "get_feedback_delay_ms".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_feedback_delay_ms" } + } + } + + val getFeedbackLevelDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "get_feedback_level_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_feedback_level_db" } + } + } + + val getFeedbackLowpass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "get_feedback_lowpass".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_feedback_lowpass" } + } + } + + val getTap1DelayMs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "get_tap1_delay_ms".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tap1_delay_ms" } + } + } + + val getTap1LevelDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "get_tap1_level_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tap1_level_db" } + } + } + + val getTap1Pan: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "get_tap1_pan".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tap1_pan" } + } + } + + val getTap2DelayMs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "get_tap2_delay_ms".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tap2_delay_ms" } + } + } + + val getTap2LevelDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "get_tap2_level_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tap2_level_db" } + } + } + + val getTap2Pan: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "get_tap2_pan".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tap2_pan" } + } + } + + val isFeedbackActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "is_feedback_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_feedback_active" } + } + } + + val isTap1Active: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "is_tap1_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_tap1_active" } + } + } + + val isTap2Active: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "is_tap2_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_tap2_active" } + } + } + + val setDry: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "set_dry".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_dry" } + } + } + + val setFeedbackActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "set_feedback_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_feedback_active" } + } + } + + val setFeedbackDelayMs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "set_feedback_delay_ms".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_feedback_delay_ms" } + } + } + + val setFeedbackLevelDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "set_feedback_level_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_feedback_level_db" } + } + } + + val setFeedbackLowpass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "set_feedback_lowpass".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_feedback_lowpass" } + } + } + + val setTap1Active: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "set_tap1_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tap1_active" } + } + } + + val setTap1DelayMs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "set_tap1_delay_ms".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tap1_delay_ms" } + } + } + + val setTap1LevelDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "set_tap1_level_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tap1_level_db" } + } + } + + val setTap1Pan: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "set_tap1_pan".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tap1_pan" } + } + } + + val setTap2Active: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "set_tap2_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tap2_active" } + } + } + + val setTap2DelayMs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "set_tap2_delay_ms".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tap2_delay_ms" } + } + } + + val setTap2LevelDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "set_tap2_level_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tap2_level_db" } + } + } + + val setTap2Pan: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDelay".cstr.ptr, + "set_tap2_pan".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tap2_pan" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectDistortion.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectDistortion.kt index 13691081..05f572fb 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectDistortion.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectDistortion.kt @@ -200,75 +200,95 @@ open class AudioEffectDistortion( * Container for method_bind pointers for AudioEffectDistortion */ private object __method_bind { - val getDrive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, - "get_drive".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_drive" } - } - val getKeepHfHz: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, - "get_keep_hf_hz".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_keep_hf_hz" } - } - val getMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, - "get_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mode" } - } - val getPostGain: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, - "get_post_gain".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_post_gain" } - } - val getPreGain: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, - "get_pre_gain".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pre_gain" } - } - val setDrive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, - "set_drive".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_drive" } - } - val setKeepHfHz: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, - "set_keep_hf_hz".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_keep_hf_hz" } - } - val setMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, - "set_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mode" } - } - val setPostGain: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, - "set_post_gain".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_post_gain" } - } - val setPreGain: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, - "set_pre_gain".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pre_gain" } - }} + val getDrive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, + "get_drive".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_drive" } + } + } + + val getKeepHfHz: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, + "get_keep_hf_hz".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_keep_hf_hz" } + } + } + + val getMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, + "get_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mode" } + } + } + + val getPostGain: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, + "get_post_gain".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_post_gain" } + } + } + + val getPreGain: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, + "get_pre_gain".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pre_gain" } + } + } + + val setDrive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, + "set_drive".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_drive" } + } + } + + val setKeepHfHz: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, + "set_keep_hf_hz".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_keep_hf_hz" } + } + } + + val setMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, + "set_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mode" } + } + } + + val setPostGain: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, + "set_post_gain".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_post_gain" } + } + } + + val setPreGain: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectDistortion".cstr.ptr, + "set_pre_gain".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pre_gain" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectEQ.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectEQ.kt index f3237d61..fd95a258 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectEQ.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectEQ.kt @@ -79,26 +79,32 @@ open class AudioEffectEQ( * Container for method_bind pointers for AudioEffectEQ */ private object __method_bind { - val getBandCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectEQ".cstr.ptr, - "get_band_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_band_count" } - } - val getBandGainDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectEQ".cstr.ptr, - "get_band_gain_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_band_gain_db" } - } - val setBandGainDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectEQ".cstr.ptr, - "set_band_gain_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_band_gain_db" } - }} + val getBandCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectEQ".cstr.ptr, + "get_band_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_band_count" } + } + } + + val getBandGainDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectEQ".cstr.ptr, + "get_band_gain_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_band_gain_db" } + } + } + + val setBandGainDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectEQ".cstr.ptr, + "set_band_gain_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_band_gain_db" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectFilter.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectFilter.kt index 0ad1a7a2..ed3765ed 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectFilter.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectFilter.kt @@ -173,61 +173,77 @@ open class AudioEffectFilter( * Container for method_bind pointers for AudioEffectFilter */ private object __method_bind { - val getCutoff: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectFilter".cstr.ptr, - "get_cutoff".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cutoff" } - } - val getDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectFilter".cstr.ptr, - "get_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_db" } - } - val getGain: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectFilter".cstr.ptr, - "get_gain".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gain" } - } - val getResonance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectFilter".cstr.ptr, - "get_resonance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_resonance" } - } - val setCutoff: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectFilter".cstr.ptr, - "set_cutoff".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cutoff" } - } - val setDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectFilter".cstr.ptr, - "set_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_db" } - } - val setGain: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectFilter".cstr.ptr, - "set_gain".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_gain" } - } - val setResonance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectFilter".cstr.ptr, - "set_resonance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_resonance" } - }} + val getCutoff: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectFilter".cstr.ptr, + "get_cutoff".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cutoff" } + } + } + + val getDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectFilter".cstr.ptr, + "get_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_db" } + } + } + + val getGain: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectFilter".cstr.ptr, + "get_gain".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gain" } + } + } + + val getResonance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectFilter".cstr.ptr, + "get_resonance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_resonance" } + } + } + + val setCutoff: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectFilter".cstr.ptr, + "set_cutoff".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cutoff" } + } + } + + val setDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectFilter".cstr.ptr, + "set_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_db" } + } + } + + val setGain: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectFilter".cstr.ptr, + "set_gain".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_gain" } + } + } + + val setResonance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectFilter".cstr.ptr, + "set_resonance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_resonance" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectLimiter.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectLimiter.kt index 1a5bcd33..bb1fc065 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectLimiter.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectLimiter.kt @@ -149,61 +149,77 @@ open class AudioEffectLimiter( * Container for method_bind pointers for AudioEffectLimiter */ private object __method_bind { - val getCeilingDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectLimiter".cstr.ptr, - "get_ceiling_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ceiling_db" } - } - val getSoftClipDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectLimiter".cstr.ptr, - "get_soft_clip_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_soft_clip_db" } - } - val getSoftClipRatio: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectLimiter".cstr.ptr, - "get_soft_clip_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_soft_clip_ratio" } - } - val getThresholdDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectLimiter".cstr.ptr, - "get_threshold_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_threshold_db" } - } - val setCeilingDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectLimiter".cstr.ptr, - "set_ceiling_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ceiling_db" } - } - val setSoftClipDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectLimiter".cstr.ptr, - "set_soft_clip_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_soft_clip_db" } - } - val setSoftClipRatio: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectLimiter".cstr.ptr, - "set_soft_clip_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_soft_clip_ratio" } - } - val setThresholdDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectLimiter".cstr.ptr, - "set_threshold_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_threshold_db" } - }} + val getCeilingDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectLimiter".cstr.ptr, + "get_ceiling_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ceiling_db" } + } + } + + val getSoftClipDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectLimiter".cstr.ptr, + "get_soft_clip_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_soft_clip_db" } + } + } + + val getSoftClipRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectLimiter".cstr.ptr, + "get_soft_clip_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_soft_clip_ratio" } + } + } + + val getThresholdDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectLimiter".cstr.ptr, + "get_threshold_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_threshold_db" } + } + } + + val setCeilingDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectLimiter".cstr.ptr, + "set_ceiling_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ceiling_db" } + } + } + + val setSoftClipDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectLimiter".cstr.ptr, + "set_soft_clip_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_soft_clip_db" } + } + } + + val setSoftClipRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectLimiter".cstr.ptr, + "set_soft_clip_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_soft_clip_ratio" } + } + } + + val setThresholdDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectLimiter".cstr.ptr, + "set_threshold_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_threshold_db" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectPanner.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectPanner.kt index 5f8b6105..5737a0d9 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectPanner.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectPanner.kt @@ -74,19 +74,23 @@ open class AudioEffectPanner( * Container for method_bind pointers for AudioEffectPanner */ private object __method_bind { - val getPan: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPanner".cstr.ptr, - "get_pan".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pan" } - } - val setPan: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPanner".cstr.ptr, - "set_pan".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pan" } - }} + val getPan: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPanner".cstr.ptr, + "get_pan".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pan" } + } + } + + val setPan: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPanner".cstr.ptr, + "set_pan".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pan" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectPhaser.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectPhaser.kt index 243564d6..f11315c2 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectPhaser.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectPhaser.kt @@ -174,75 +174,95 @@ open class AudioEffectPhaser( * Container for method_bind pointers for AudioEffectPhaser */ private object __method_bind { - val getDepth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, - "get_depth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_depth" } - } - val getFeedback: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, - "get_feedback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_feedback" } - } - val getRangeMaxHz: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, - "get_range_max_hz".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_range_max_hz" } - } - val getRangeMinHz: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, - "get_range_min_hz".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_range_min_hz" } - } - val getRateHz: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, - "get_rate_hz".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rate_hz" } - } - val setDepth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, - "set_depth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_depth" } - } - val setFeedback: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, - "set_feedback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_feedback" } - } - val setRangeMaxHz: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, - "set_range_max_hz".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_range_max_hz" } - } - val setRangeMinHz: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, - "set_range_min_hz".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_range_min_hz" } - } - val setRateHz: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, - "set_rate_hz".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rate_hz" } - }} + val getDepth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, + "get_depth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_depth" } + } + } + + val getFeedback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, + "get_feedback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_feedback" } + } + } + + val getRangeMaxHz: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, + "get_range_max_hz".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_range_max_hz" } + } + } + + val getRangeMinHz: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, + "get_range_min_hz".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_range_min_hz" } + } + } + + val getRateHz: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, + "get_rate_hz".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rate_hz" } + } + } + + val setDepth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, + "set_depth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_depth" } + } + } + + val setFeedback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, + "set_feedback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_feedback" } + } + } + + val setRangeMaxHz: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, + "set_range_max_hz".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_range_max_hz" } + } + } + + val setRangeMinHz: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, + "set_range_min_hz".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_range_min_hz" } + } + } + + val setRateHz: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPhaser".cstr.ptr, + "set_rate_hz".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rate_hz" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectPitchShift.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectPitchShift.kt index 878ded0c..cf1e747d 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectPitchShift.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectPitchShift.kt @@ -152,47 +152,59 @@ open class AudioEffectPitchShift( * Container for method_bind pointers for AudioEffectPitchShift */ private object __method_bind { - val getFftSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPitchShift".cstr.ptr, - "get_fft_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fft_size" } - } - val getOversampling: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPitchShift".cstr.ptr, - "get_oversampling".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_oversampling" } - } - val getPitchScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPitchShift".cstr.ptr, - "get_pitch_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pitch_scale" } - } - val setFftSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPitchShift".cstr.ptr, - "set_fft_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fft_size" } - } - val setOversampling: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPitchShift".cstr.ptr, - "set_oversampling".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_oversampling" } - } - val setPitchScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPitchShift".cstr.ptr, - "set_pitch_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pitch_scale" } - }} + val getFftSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPitchShift".cstr.ptr, + "get_fft_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fft_size" } + } + } + + val getOversampling: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPitchShift".cstr.ptr, + "get_oversampling".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_oversampling" } + } + } + + val getPitchScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPitchShift".cstr.ptr, + "get_pitch_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pitch_scale" } + } + } + + val setFftSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPitchShift".cstr.ptr, + "set_fft_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fft_size" } + } + } + + val setOversampling: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPitchShift".cstr.ptr, + "set_oversampling".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_oversampling" } + } + } + + val setPitchScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectPitchShift".cstr.ptr, + "set_pitch_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pitch_scale" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectRecord.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectRecord.kt index ebad00a8..f8e00ff0 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectRecord.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectRecord.kt @@ -104,40 +104,50 @@ open class AudioEffectRecord( * Container for method_bind pointers for AudioEffectRecord */ private object __method_bind { - val getFormat: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectRecord".cstr.ptr, - "get_format".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_format" } - } - val getRecording: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectRecord".cstr.ptr, - "get_recording".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_recording" } - } - val isRecordingActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectRecord".cstr.ptr, - "is_recording_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_recording_active" } - } - val setFormat: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectRecord".cstr.ptr, - "set_format".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_format" } - } - val setRecordingActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectRecord".cstr.ptr, - "set_recording_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_recording_active" } - }} + val getFormat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectRecord".cstr.ptr, + "get_format".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_format" } + } + } + + val getRecording: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectRecord".cstr.ptr, + "get_recording".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_recording" } + } + } + + val isRecordingActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectRecord".cstr.ptr, + "is_recording_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_recording_active" } + } + } + + val setFormat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectRecord".cstr.ptr, + "set_format".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_format" } + } + } + + val setRecordingActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectRecord".cstr.ptr, + "set_recording_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_recording_active" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectReverb.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectReverb.kt index 5a7efcab..ddfbbd0f 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectReverb.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectReverb.kt @@ -249,117 +249,149 @@ open class AudioEffectReverb( * Container for method_bind pointers for AudioEffectReverb */ private object __method_bind { - val getDamping: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, - "get_damping".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_damping" } - } - val getDry: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, - "get_dry".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_dry" } - } - val getHpf: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, - "get_hpf".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_hpf" } - } - val getPredelayFeedback: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, - "get_predelay_feedback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_predelay_feedback" } - } - val getPredelayMsec: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, - "get_predelay_msec".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_predelay_msec" } - } - val getRoomSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, - "get_room_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_room_size" } - } - val getSpread: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, - "get_spread".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_spread" } - } - val getWet: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, - "get_wet".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_wet" } - } - val setDamping: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, - "set_damping".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_damping" } - } - val setDry: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, - "set_dry".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_dry" } - } - val setHpf: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, - "set_hpf".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_hpf" } - } - val setPredelayFeedback: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, - "set_predelay_feedback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_predelay_feedback" } - } - val setPredelayMsec: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, - "set_predelay_msec".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_predelay_msec" } - } - val setRoomSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, - "set_room_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_room_size" } - } - val setSpread: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, - "set_spread".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_spread" } - } - val setWet: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, - "set_wet".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_wet" } - }} + val getDamping: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, + "get_damping".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_damping" } + } + } + + val getDry: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, + "get_dry".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_dry" } + } + } + + val getHpf: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, + "get_hpf".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_hpf" } + } + } + + val getPredelayFeedback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, + "get_predelay_feedback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_predelay_feedback" } + } + } + + val getPredelayMsec: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, + "get_predelay_msec".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_predelay_msec" } + } + } + + val getRoomSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, + "get_room_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_room_size" } + } + } + + val getSpread: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, + "get_spread".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_spread" } + } + } + + val getWet: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, + "get_wet".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_wet" } + } + } + + val setDamping: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, + "set_damping".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_damping" } + } + } + + val setDry: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, + "set_dry".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_dry" } + } + } + + val setHpf: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, + "set_hpf".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_hpf" } + } + } + + val setPredelayFeedback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, + "set_predelay_feedback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_predelay_feedback" } + } + } + + val setPredelayMsec: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, + "set_predelay_msec".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_predelay_msec" } + } + } + + val setRoomSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, + "set_room_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_room_size" } + } + } + + val setSpread: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, + "set_spread".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_spread" } + } + } + + val setWet: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectReverb".cstr.ptr, + "set_wet".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_wet" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectSpectrumAnalyzer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectSpectrumAnalyzer.kt index 60622a4e..e8fd72ae 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectSpectrumAnalyzer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectSpectrumAnalyzer.kt @@ -152,47 +152,59 @@ open class AudioEffectSpectrumAnalyzer( * Container for method_bind pointers for AudioEffectSpectrumAnalyzer */ private object __method_bind { - val getBufferLength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectSpectrumAnalyzer".cstr.ptr, - "get_buffer_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_buffer_length" } - } - val getFftSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectSpectrumAnalyzer".cstr.ptr, - "get_fft_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fft_size" } - } - val getTapBackPos: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectSpectrumAnalyzer".cstr.ptr, - "get_tap_back_pos".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tap_back_pos" } - } - val setBufferLength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectSpectrumAnalyzer".cstr.ptr, - "set_buffer_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_buffer_length" } - } - val setFftSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectSpectrumAnalyzer".cstr.ptr, - "set_fft_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fft_size" } - } - val setTapBackPos: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectSpectrumAnalyzer".cstr.ptr, - "set_tap_back_pos".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tap_back_pos" } - }} + val getBufferLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectSpectrumAnalyzer".cstr.ptr, + "get_buffer_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_buffer_length" } + } + } + + val getFftSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectSpectrumAnalyzer".cstr.ptr, + "get_fft_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fft_size" } + } + } + + val getTapBackPos: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectSpectrumAnalyzer".cstr.ptr, + "get_tap_back_pos".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tap_back_pos" } + } + } + + val setBufferLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectSpectrumAnalyzer".cstr.ptr, + "set_buffer_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_buffer_length" } + } + } + + val setFftSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectSpectrumAnalyzer".cstr.ptr, + "set_fft_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fft_size" } + } + } + + val setTapBackPos: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectSpectrumAnalyzer".cstr.ptr, + "set_tap_back_pos".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tap_back_pos" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectSpectrumAnalyzerInstance.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectSpectrumAnalyzerInstance.kt index c5d6aafb..d191612f 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectSpectrumAnalyzerInstance.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectSpectrumAnalyzerInstance.kt @@ -82,13 +82,15 @@ open class AudioEffectSpectrumAnalyzerInstance( * Container for method_bind pointers for AudioEffectSpectrumAnalyzerInstance */ private object __method_bind { - val getMagnitudeForFrequencyRange: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectSpectrumAnalyzerInstance".cstr.ptr, - "get_magnitude_for_frequency_range".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_magnitude_for_frequency_range" + val getMagnitudeForFrequencyRange: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectSpectrumAnalyzerInstance".cstr.ptr, + "get_magnitude_for_frequency_range".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_magnitude_for_frequency_range" } } - }} + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectStereoEnhance.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectStereoEnhance.kt index dcdebaff..0d6b9f9d 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectStereoEnhance.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioEffectStereoEnhance.kt @@ -124,47 +124,59 @@ open class AudioEffectStereoEnhance( * Container for method_bind pointers for AudioEffectStereoEnhance */ private object __method_bind { - val getPanPullout: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectStereoEnhance".cstr.ptr, - "get_pan_pullout".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pan_pullout" } - } - val getSurround: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectStereoEnhance".cstr.ptr, - "get_surround".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_surround" } - } - val getTimePullout: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectStereoEnhance".cstr.ptr, - "get_time_pullout".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_time_pullout" } - } - val setPanPullout: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectStereoEnhance".cstr.ptr, - "set_pan_pullout".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pan_pullout" } - } - val setSurround: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectStereoEnhance".cstr.ptr, - "set_surround".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_surround" } - } - val setTimePullout: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectStereoEnhance".cstr.ptr, - "set_time_pullout".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_time_pullout" } - }} + val getPanPullout: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectStereoEnhance".cstr.ptr, + "get_pan_pullout".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pan_pullout" } + } + } + + val getSurround: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectStereoEnhance".cstr.ptr, + "get_surround".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_surround" } + } + } + + val getTimePullout: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectStereoEnhance".cstr.ptr, + "get_time_pullout".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_time_pullout" } + } + } + + val setPanPullout: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectStereoEnhance".cstr.ptr, + "set_pan_pullout".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pan_pullout" } + } + } + + val setSurround: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectStereoEnhance".cstr.ptr, + "set_surround".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_surround" } + } + } + + val setTimePullout: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioEffectStereoEnhance".cstr.ptr, + "set_time_pullout".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_time_pullout" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioServer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioServer.kt index 96267d5e..553dda09 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioServer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioServer.kt @@ -547,328 +547,420 @@ open class AudioServerInternal( * Container for method_bind pointers for AudioServer */ private object __method_bind { - val addBus: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "add_bus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_bus" } - } - val addBusEffect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "add_bus_effect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_bus_effect" } - } - val captureGetDevice: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "capture_get_device".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method capture_get_device" } - } - val captureGetDeviceList: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "capture_get_device_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method capture_get_device_list" } - } - val captureSetDevice: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "capture_set_device".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method capture_set_device" } - } - val generateBusLayout: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "generate_bus_layout".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method generate_bus_layout" } - } - val getBusChannels: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "get_bus_channels".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bus_channels" } - } - val getBusCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "get_bus_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bus_count" } - } - val getBusEffect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "get_bus_effect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bus_effect" } - } - val getBusEffectCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "get_bus_effect_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bus_effect_count" } - } - val getBusEffectInstance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "get_bus_effect_instance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bus_effect_instance" } - } - val getBusIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "get_bus_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bus_index" } - } - val getBusName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "get_bus_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bus_name" } - } - val getBusPeakVolumeLeftDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "get_bus_peak_volume_left_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bus_peak_volume_left_db" } - } - val getBusPeakVolumeRightDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "get_bus_peak_volume_right_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bus_peak_volume_right_db" } - } - val getBusSend: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "get_bus_send".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bus_send" } - } - val getBusVolumeDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "get_bus_volume_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bus_volume_db" } - } - val getDevice: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "get_device".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_device" } - } - val getDeviceList: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "get_device_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_device_list" } - } - val getGlobalRateScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "get_global_rate_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_global_rate_scale" } - } - val getMixRate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "get_mix_rate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mix_rate" } - } - val getOutputLatency: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "get_output_latency".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_output_latency" } - } - val getSpeakerMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "get_speaker_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_speaker_mode" } - } - val getTimeSinceLastMix: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "get_time_since_last_mix".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_time_since_last_mix" } - } - val getTimeToNextMix: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "get_time_to_next_mix".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_time_to_next_mix" } - } - val isBusBypassingEffects: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "is_bus_bypassing_effects".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_bus_bypassing_effects" } - } - val isBusEffectEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "is_bus_effect_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_bus_effect_enabled" } - } - val isBusMute: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "is_bus_mute".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_bus_mute" } - } - val isBusSolo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "is_bus_solo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_bus_solo" } - } - val lock: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "lock".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method lock" } - } - val moveBus: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "move_bus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method move_bus" } - } - val removeBus: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "remove_bus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_bus" } - } - val removeBusEffect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "remove_bus_effect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_bus_effect" } - } - val setBusBypassEffects: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "set_bus_bypass_effects".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bus_bypass_effects" } - } - val setBusCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "set_bus_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bus_count" } - } - val setBusEffectEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "set_bus_effect_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bus_effect_enabled" } - } - val setBusLayout: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "set_bus_layout".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bus_layout" } - } - val setBusMute: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "set_bus_mute".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bus_mute" } - } - val setBusName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "set_bus_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bus_name" } - } - val setBusSend: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "set_bus_send".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bus_send" } - } - val setBusSolo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "set_bus_solo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bus_solo" } - } - val setBusVolumeDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "set_bus_volume_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bus_volume_db" } - } - val setDevice: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "set_device".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_device" } - } - val setGlobalRateScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "set_global_rate_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_global_rate_scale" } - } - val swapBusEffects: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "swap_bus_effects".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method swap_bus_effects" } - } - val unlock: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, - "unlock".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method unlock" } - }} + val addBus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "add_bus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_bus" } + } + } + + val addBusEffect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "add_bus_effect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_bus_effect" } + } + } + + val captureGetDevice: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "capture_get_device".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method capture_get_device" } + } + } + + val captureGetDeviceList: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "capture_get_device_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method capture_get_device_list" } + } + } + + val captureSetDevice: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "capture_set_device".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method capture_set_device" } + } + } + + val generateBusLayout: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "generate_bus_layout".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method generate_bus_layout" } + } + } + + val getBusChannels: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "get_bus_channels".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bus_channels" } + } + } + + val getBusCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "get_bus_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bus_count" } + } + } + + val getBusEffect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "get_bus_effect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bus_effect" } + } + } + + val getBusEffectCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "get_bus_effect_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bus_effect_count" } + } + } + + val getBusEffectInstance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "get_bus_effect_instance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bus_effect_instance" } + } + } + + val getBusIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "get_bus_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bus_index" } + } + } + + val getBusName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "get_bus_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bus_name" } + } + } + + val getBusPeakVolumeLeftDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "get_bus_peak_volume_left_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bus_peak_volume_left_db" } + } + } + + val getBusPeakVolumeRightDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "get_bus_peak_volume_right_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bus_peak_volume_right_db" } + } + } + + val getBusSend: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "get_bus_send".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bus_send" } + } + } + + val getBusVolumeDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "get_bus_volume_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bus_volume_db" } + } + } + + val getDevice: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "get_device".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_device" } + } + } + + val getDeviceList: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "get_device_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_device_list" } + } + } + + val getGlobalRateScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "get_global_rate_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_global_rate_scale" } + } + } + + val getMixRate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "get_mix_rate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mix_rate" } + } + } + + val getOutputLatency: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "get_output_latency".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_output_latency" } + } + } + + val getSpeakerMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "get_speaker_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_speaker_mode" } + } + } + + val getTimeSinceLastMix: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "get_time_since_last_mix".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_time_since_last_mix" } + } + } + + val getTimeToNextMix: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "get_time_to_next_mix".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_time_to_next_mix" } + } + } + + val isBusBypassingEffects: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "is_bus_bypassing_effects".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_bus_bypassing_effects" } + } + } + + val isBusEffectEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "is_bus_effect_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_bus_effect_enabled" } + } + } + + val isBusMute: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "is_bus_mute".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_bus_mute" } + } + } + + val isBusSolo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "is_bus_solo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_bus_solo" } + } + } + + val lock: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "lock".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method lock" } + } + } + + val moveBus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "move_bus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method move_bus" } + } + } + + val removeBus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "remove_bus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_bus" } + } + } + + val removeBusEffect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "remove_bus_effect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_bus_effect" } + } + } + + val setBusBypassEffects: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "set_bus_bypass_effects".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bus_bypass_effects" } + } + } + + val setBusCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "set_bus_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bus_count" } + } + } + + val setBusEffectEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "set_bus_effect_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bus_effect_enabled" } + } + } + + val setBusLayout: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "set_bus_layout".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bus_layout" } + } + } + + val setBusMute: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "set_bus_mute".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bus_mute" } + } + } + + val setBusName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "set_bus_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bus_name" } + } + } + + val setBusSend: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "set_bus_send".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bus_send" } + } + } + + val setBusSolo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "set_bus_solo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bus_solo" } + } + } + + val setBusVolumeDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "set_bus_volume_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bus_volume_db" } + } + } + + val setDevice: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "set_device".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_device" } + } + } + + val setGlobalRateScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "set_global_rate_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_global_rate_scale" } + } + } + + val swapBusEffects: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "swap_bus_effects".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method swap_bus_effects" } + } + } + + val unlock: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioServer".cstr.ptr, + "unlock".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method unlock" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioStream.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioStream.kt index f5e8a6b6..e4c17111 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioStream.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioStream.kt @@ -52,12 +52,14 @@ open class AudioStream( * Container for method_bind pointers for AudioStream */ private object __method_bind { - val getLength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStream".cstr.ptr, - "get_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_length" } - }} + val getLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStream".cstr.ptr, + "get_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_length" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamGenerator.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamGenerator.kt index a34e32e9..c57e601e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamGenerator.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamGenerator.kt @@ -99,33 +99,41 @@ open class AudioStreamGenerator( * Container for method_bind pointers for AudioStreamGenerator */ private object __method_bind { - val getBufferLength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGenerator".cstr.ptr, - "get_buffer_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_buffer_length" } - } - val getMixRate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGenerator".cstr.ptr, - "get_mix_rate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mix_rate" } - } - val setBufferLength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGenerator".cstr.ptr, - "set_buffer_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_buffer_length" } - } - val setMixRate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGenerator".cstr.ptr, - "set_mix_rate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mix_rate" } - }} + val getBufferLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGenerator".cstr.ptr, + "get_buffer_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_buffer_length" } + } + } + + val getMixRate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGenerator".cstr.ptr, + "get_mix_rate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mix_rate" } + } + } + + val setBufferLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGenerator".cstr.ptr, + "set_buffer_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_buffer_length" } + } + } + + val setMixRate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGenerator".cstr.ptr, + "set_mix_rate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mix_rate" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamGeneratorPlayback.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamGeneratorPlayback.kt index 449b6151..f09d2693 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamGeneratorPlayback.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamGeneratorPlayback.kt @@ -102,47 +102,59 @@ open class AudioStreamGeneratorPlayback( * Container for method_bind pointers for AudioStreamGeneratorPlayback */ private object __method_bind { - val canPushBuffer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGeneratorPlayback".cstr.ptr, - "can_push_buffer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method can_push_buffer" } - } - val clearBuffer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGeneratorPlayback".cstr.ptr, - "clear_buffer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_buffer" } - } - val getFramesAvailable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGeneratorPlayback".cstr.ptr, - "get_frames_available".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_frames_available" } - } - val getSkips: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGeneratorPlayback".cstr.ptr, - "get_skips".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_skips" } - } - val pushBuffer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGeneratorPlayback".cstr.ptr, - "push_buffer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method push_buffer" } - } - val pushFrame: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGeneratorPlayback".cstr.ptr, - "push_frame".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method push_frame" } - }} + val canPushBuffer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGeneratorPlayback".cstr.ptr, + "can_push_buffer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method can_push_buffer" } + } + } + + val clearBuffer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGeneratorPlayback".cstr.ptr, + "clear_buffer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_buffer" } + } + } + + val getFramesAvailable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGeneratorPlayback".cstr.ptr, + "get_frames_available".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_frames_available" } + } + } + + val getSkips: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGeneratorPlayback".cstr.ptr, + "get_skips".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_skips" } + } + } + + val pushBuffer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGeneratorPlayback".cstr.ptr, + "push_buffer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method push_buffer" } + } + } + + val pushFrame: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamGeneratorPlayback".cstr.ptr, + "push_frame".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method push_frame" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamOGGVorbis.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamOGGVorbis.kt index b0cd4778..fe0885b9 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamOGGVorbis.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamOGGVorbis.kt @@ -137,47 +137,59 @@ open class AudioStreamOGGVorbis( * Container for method_bind pointers for AudioStreamOGGVorbis */ private object __method_bind { - val getData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamOGGVorbis".cstr.ptr, - "get_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_data" } - } - val getLoopOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamOGGVorbis".cstr.ptr, - "get_loop_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_loop_offset" } - } - val hasLoop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamOGGVorbis".cstr.ptr, - "has_loop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_loop" } - } - val setData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamOGGVorbis".cstr.ptr, - "set_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_data" } - } - val setLoop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamOGGVorbis".cstr.ptr, - "set_loop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_loop" } - } - val setLoopOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamOGGVorbis".cstr.ptr, - "set_loop_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_loop_offset" } - }} + val getData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamOGGVorbis".cstr.ptr, + "get_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_data" } + } + } + + val getLoopOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamOGGVorbis".cstr.ptr, + "get_loop_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_loop_offset" } + } + } + + val hasLoop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamOGGVorbis".cstr.ptr, + "has_loop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_loop" } + } + } + + val setData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamOGGVorbis".cstr.ptr, + "set_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_data" } + } + } + + val setLoop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamOGGVorbis".cstr.ptr, + "set_loop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_loop" } + } + } + + val setLoopOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamOGGVorbis".cstr.ptr, + "set_loop_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_loop_offset" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamPlayer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamPlayer.kt index 05ab69c4..abd306d7 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamPlayer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamPlayer.kt @@ -320,145 +320,185 @@ open class AudioStreamPlayer( * Container for method_bind pointers for AudioStreamPlayer */ private object __method_bind { - val getBus: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "get_bus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bus" } - } - val getMixTarget: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "get_mix_target".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mix_target" } - } - val getPitchScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "get_pitch_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pitch_scale" } - } - val getPlaybackPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "get_playback_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_playback_position" } - } - val getStream: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "get_stream".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stream" } - } - val getStreamPaused: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "get_stream_paused".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stream_paused" } - } - val getStreamPlayback: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "get_stream_playback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stream_playback" } - } - val getVolumeDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "get_volume_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_volume_db" } - } - val isAutoplayEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "is_autoplay_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_autoplay_enabled" } - } - val isPlaying: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "is_playing".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_playing" } - } - val play: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "play".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method play" } - } - val seek: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "seek".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method seek" } - } - val setAutoplay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "set_autoplay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_autoplay" } - } - val setBus: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "set_bus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bus" } - } - val setMixTarget: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "set_mix_target".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mix_target" } - } - val setPitchScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "set_pitch_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pitch_scale" } - } - val setStream: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "set_stream".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_stream" } - } - val setStreamPaused: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "set_stream_paused".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_stream_paused" } - } - val setVolumeDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "set_volume_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_volume_db" } - } - val stop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, - "stop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method stop" } - }} + val getBus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "get_bus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bus" } + } + } + + val getMixTarget: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "get_mix_target".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mix_target" } + } + } + + val getPitchScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "get_pitch_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pitch_scale" } + } + } + + val getPlaybackPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "get_playback_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_playback_position" } + } + } + + val getStream: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "get_stream".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stream" } + } + } + + val getStreamPaused: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "get_stream_paused".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stream_paused" } + } + } + + val getStreamPlayback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "get_stream_playback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stream_playback" } + } + } + + val getVolumeDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "get_volume_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_volume_db" } + } + } + + val isAutoplayEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "is_autoplay_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_autoplay_enabled" } + } + } + + val isPlaying: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "is_playing".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_playing" } + } + } + + val play: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "play".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method play" } + } + } + + val seek: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "seek".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method seek" } + } + } + + val setAutoplay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "set_autoplay".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_autoplay" } + } + } + + val setBus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "set_bus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bus" } + } + } + + val setMixTarget: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "set_mix_target".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mix_target" } + } + } + + val setPitchScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "set_pitch_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pitch_scale" } + } + } + + val setStream: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "set_stream".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_stream" } + } + } + + val setStreamPaused: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "set_stream_paused".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_stream_paused" } + } + } + + val setVolumeDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "set_volume_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_volume_db" } + } + } + + val stop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer".cstr.ptr, + "stop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method stop" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamPlayer2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamPlayer2D.kt index 40882a12..31ef1816 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamPlayer2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamPlayer2D.kt @@ -349,173 +349,221 @@ open class AudioStreamPlayer2D( * Container for method_bind pointers for AudioStreamPlayer2D */ private object __method_bind { - val getAreaMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "get_area_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_area_mask" } - } - val getAttenuation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "get_attenuation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_attenuation" } - } - val getBus: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "get_bus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bus" } - } - val getMaxDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "get_max_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_max_distance" } - } - val getPitchScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "get_pitch_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pitch_scale" } - } - val getPlaybackPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "get_playback_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_playback_position" } - } - val getStream: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "get_stream".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stream" } - } - val getStreamPaused: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "get_stream_paused".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stream_paused" } - } - val getStreamPlayback: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "get_stream_playback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stream_playback" } - } - val getVolumeDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "get_volume_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_volume_db" } - } - val isAutoplayEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "is_autoplay_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_autoplay_enabled" } - } - val isPlaying: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "is_playing".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_playing" } - } - val play: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "play".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method play" } - } - val seek: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "seek".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method seek" } - } - val setAreaMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "set_area_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_area_mask" } - } - val setAttenuation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "set_attenuation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_attenuation" } - } - val setAutoplay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "set_autoplay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_autoplay" } - } - val setBus: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "set_bus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bus" } - } - val setMaxDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "set_max_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_max_distance" } - } - val setPitchScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "set_pitch_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pitch_scale" } - } - val setStream: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "set_stream".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_stream" } - } - val setStreamPaused: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "set_stream_paused".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_stream_paused" } - } - val setVolumeDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "set_volume_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_volume_db" } - } - val stop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, - "stop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method stop" } - }} + val getAreaMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "get_area_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_area_mask" } + } + } + + val getAttenuation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "get_attenuation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_attenuation" } + } + } + + val getBus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "get_bus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bus" } + } + } + + val getMaxDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "get_max_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_max_distance" } + } + } + + val getPitchScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "get_pitch_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pitch_scale" } + } + } + + val getPlaybackPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "get_playback_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_playback_position" } + } + } + + val getStream: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "get_stream".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stream" } + } + } + + val getStreamPaused: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "get_stream_paused".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stream_paused" } + } + } + + val getStreamPlayback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "get_stream_playback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stream_playback" } + } + } + + val getVolumeDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "get_volume_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_volume_db" } + } + } + + val isAutoplayEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "is_autoplay_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_autoplay_enabled" } + } + } + + val isPlaying: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "is_playing".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_playing" } + } + } + + val play: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "play".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method play" } + } + } + + val seek: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "seek".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method seek" } + } + } + + val setAreaMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "set_area_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_area_mask" } + } + } + + val setAttenuation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "set_attenuation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_attenuation" } + } + } + + val setAutoplay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "set_autoplay".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_autoplay" } + } + } + + val setBus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "set_bus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bus" } + } + } + + val setMaxDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "set_max_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_max_distance" } + } + } + + val setPitchScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "set_pitch_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pitch_scale" } + } + } + + val setStream: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "set_stream".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_stream" } + } + } + + val setStreamPaused: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "set_stream_paused".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_stream_paused" } + } + } + + val setVolumeDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "set_volume_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_volume_db" } + } + } + + val stop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer2D".cstr.ptr, + "stop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method stop" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamPlayer3D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamPlayer3D.kt index c0e116f9..25526bb3 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamPlayer3D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamPlayer3D.kt @@ -637,301 +637,387 @@ open class AudioStreamPlayer3D( * Container for method_bind pointers for AudioStreamPlayer3D */ private object __method_bind { - val getAreaMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "get_area_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_area_mask" } - } - val getAttenuationFilterCutoffHz: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "get_attenuation_filter_cutoff_hz".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_attenuation_filter_cutoff_hz" } - } - val getAttenuationFilterDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "get_attenuation_filter_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_attenuation_filter_db" } - } - val getAttenuationModel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "get_attenuation_model".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_attenuation_model" } - } - val getBus: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "get_bus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bus" } - } - val getDopplerTracking: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "get_doppler_tracking".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_doppler_tracking" } - } - val getEmissionAngle: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "get_emission_angle".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_angle" } - } - val getEmissionAngleFilterAttenuationDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "get_emission_angle_filter_attenuation_db".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method get_emission_angle_filter_attenuation_db" } - } - val getMaxDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "get_max_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_max_db" } - } - val getMaxDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "get_max_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_max_distance" } - } - val getOutOfRangeMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "get_out_of_range_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_out_of_range_mode" } - } - val getPitchScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "get_pitch_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pitch_scale" } - } - val getPlaybackPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "get_playback_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_playback_position" } - } - val getStream: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "get_stream".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stream" } - } - val getStreamPaused: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "get_stream_paused".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stream_paused" } - } - val getStreamPlayback: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "get_stream_playback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stream_playback" } - } - val getUnitDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "get_unit_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_unit_db" } - } - val getUnitSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "get_unit_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_unit_size" } - } - val isAutoplayEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "is_autoplay_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_autoplay_enabled" } - } - val isEmissionAngleEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "is_emission_angle_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_emission_angle_enabled" } - } - val isPlaying: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "is_playing".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_playing" } - } - val play: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "play".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method play" } - } - val seek: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "seek".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method seek" } - } - val setAreaMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "set_area_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_area_mask" } - } - val setAttenuationFilterCutoffHz: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "set_attenuation_filter_cutoff_hz".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_attenuation_filter_cutoff_hz" } - } - val setAttenuationFilterDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "set_attenuation_filter_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_attenuation_filter_db" } - } - val setAttenuationModel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "set_attenuation_model".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_attenuation_model" } - } - val setAutoplay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "set_autoplay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_autoplay" } - } - val setBus: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "set_bus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bus" } - } - val setDopplerTracking: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "set_doppler_tracking".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_doppler_tracking" } - } - val setEmissionAngle: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "set_emission_angle".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_angle" } - } - val setEmissionAngleEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "set_emission_angle_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_angle_enabled" } - } - val setEmissionAngleFilterAttenuationDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "set_emission_angle_filter_attenuation_db".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method set_emission_angle_filter_attenuation_db" } - } - val setMaxDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "set_max_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_max_db" } - } - val setMaxDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "set_max_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_max_distance" } - } - val setOutOfRangeMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "set_out_of_range_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_out_of_range_mode" } - } - val setPitchScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "set_pitch_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pitch_scale" } - } - val setStream: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "set_stream".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_stream" } - } - val setStreamPaused: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "set_stream_paused".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_stream_paused" } - } - val setUnitDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "set_unit_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_unit_db" } - } - val setUnitSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "set_unit_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_unit_size" } - } - val stop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, - "stop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method stop" } - }} + val getAreaMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "get_area_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_area_mask" } + } + } + + val getAttenuationFilterCutoffHz: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "get_attenuation_filter_cutoff_hz".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_attenuation_filter_cutoff_hz" } + } + } + + val getAttenuationFilterDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "get_attenuation_filter_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_attenuation_filter_db" } + } + } + + val getAttenuationModel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "get_attenuation_model".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_attenuation_model" } + } + } + + val getBus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "get_bus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bus" } + } + } + + val getDopplerTracking: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "get_doppler_tracking".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_doppler_tracking" } + } + } + + val getEmissionAngle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "get_emission_angle".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_angle" } + } + } + + val getEmissionAngleFilterAttenuationDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "get_emission_angle_filter_attenuation_db".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_emission_angle_filter_attenuation_db" } + } + } + + val getMaxDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "get_max_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_max_db" } + } + } + + val getMaxDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "get_max_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_max_distance" } + } + } + + val getOutOfRangeMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "get_out_of_range_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_out_of_range_mode" } + } + } + + val getPitchScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "get_pitch_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pitch_scale" } + } + } + + val getPlaybackPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "get_playback_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_playback_position" } + } + } + + val getStream: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "get_stream".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stream" } + } + } + + val getStreamPaused: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "get_stream_paused".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stream_paused" } + } + } + + val getStreamPlayback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "get_stream_playback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stream_playback" } + } + } + + val getUnitDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "get_unit_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_unit_db" } + } + } + + val getUnitSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "get_unit_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_unit_size" } + } + } + + val isAutoplayEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "is_autoplay_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_autoplay_enabled" } + } + } + + val isEmissionAngleEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "is_emission_angle_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_emission_angle_enabled" } + } + } + + val isPlaying: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "is_playing".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_playing" } + } + } + + val play: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "play".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method play" } + } + } + + val seek: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "seek".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method seek" } + } + } + + val setAreaMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "set_area_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_area_mask" } + } + } + + val setAttenuationFilterCutoffHz: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "set_attenuation_filter_cutoff_hz".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_attenuation_filter_cutoff_hz" } + } + } + + val setAttenuationFilterDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "set_attenuation_filter_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_attenuation_filter_db" } + } + } + + val setAttenuationModel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "set_attenuation_model".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_attenuation_model" } + } + } + + val setAutoplay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "set_autoplay".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_autoplay" } + } + } + + val setBus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "set_bus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bus" } + } + } + + val setDopplerTracking: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "set_doppler_tracking".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_doppler_tracking" } + } + } + + val setEmissionAngle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "set_emission_angle".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_angle" } + } + } + + val setEmissionAngleEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "set_emission_angle_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_angle_enabled" } + } + } + + val setEmissionAngleFilterAttenuationDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "set_emission_angle_filter_attenuation_db".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_emission_angle_filter_attenuation_db" } + } + } + + val setMaxDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "set_max_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_max_db" } + } + } + + val setMaxDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "set_max_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_max_distance" } + } + } + + val setOutOfRangeMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "set_out_of_range_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_out_of_range_mode" } + } + } + + val setPitchScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "set_pitch_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pitch_scale" } + } + } + + val setStream: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "set_stream".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_stream" } + } + } + + val setStreamPaused: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "set_stream_paused".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_stream_paused" } + } + } + + val setUnitDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "set_unit_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_unit_db" } + } + } + + val setUnitSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "set_unit_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_unit_size" } + } + } + + val stop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamPlayer3D".cstr.ptr, + "stop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method stop" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamRandomPitch.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamRandomPitch.kt index bef2cbe3..9038eb83 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamRandomPitch.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamRandomPitch.kt @@ -101,33 +101,41 @@ open class AudioStreamRandomPitch( * Container for method_bind pointers for AudioStreamRandomPitch */ private object __method_bind { - val getAudioStream: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamRandomPitch".cstr.ptr, - "get_audio_stream".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_audio_stream" } - } - val getRandomPitch: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamRandomPitch".cstr.ptr, - "get_random_pitch".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_random_pitch" } - } - val setAudioStream: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamRandomPitch".cstr.ptr, - "set_audio_stream".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_audio_stream" } - } - val setRandomPitch: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamRandomPitch".cstr.ptr, - "set_random_pitch".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_random_pitch" } - }} + val getAudioStream: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamRandomPitch".cstr.ptr, + "get_audio_stream".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_audio_stream" } + } + } + + val getRandomPitch: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamRandomPitch".cstr.ptr, + "get_random_pitch".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_random_pitch" } + } + } + + val setAudioStream: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamRandomPitch".cstr.ptr, + "set_audio_stream".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_audio_stream" } + } + } + + val setRandomPitch: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamRandomPitch".cstr.ptr, + "set_random_pitch".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_random_pitch" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamSample.kt b/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamSample.kt index b01fd0e2..905cdb47 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamSample.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/AudioStreamSample.kt @@ -292,110 +292,140 @@ open class AudioStreamSample( * Container for method_bind pointers for AudioStreamSample */ private object __method_bind { - val getData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, - "get_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_data" } - } - val getFormat: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, - "get_format".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_format" } - } - val getLoopBegin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, - "get_loop_begin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_loop_begin" } - } - val getLoopEnd: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, - "get_loop_end".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_loop_end" } - } - val getLoopMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, - "get_loop_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_loop_mode" } - } - val getMixRate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, - "get_mix_rate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mix_rate" } - } - val isStereo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, - "is_stereo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_stereo" } - } - val saveToWav: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, - "save_to_wav".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method save_to_wav" } - } - val setData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, - "set_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_data" } - } - val setFormat: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, - "set_format".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_format" } - } - val setLoopBegin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, - "set_loop_begin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_loop_begin" } - } - val setLoopEnd: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, - "set_loop_end".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_loop_end" } - } - val setLoopMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, - "set_loop_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_loop_mode" } - } - val setMixRate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, - "set_mix_rate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mix_rate" } - } - val setStereo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, - "set_stereo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_stereo" } - }} + val getData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, + "get_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_data" } + } + } + + val getFormat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, + "get_format".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_format" } + } + } + + val getLoopBegin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, + "get_loop_begin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_loop_begin" } + } + } + + val getLoopEnd: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, + "get_loop_end".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_loop_end" } + } + } + + val getLoopMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, + "get_loop_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_loop_mode" } + } + } + + val getMixRate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, + "get_mix_rate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mix_rate" } + } + } + + val isStereo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, + "is_stereo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_stereo" } + } + } + + val saveToWav: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, + "save_to_wav".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method save_to_wav" } + } + } + + val setData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, + "set_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_data" } + } + } + + val setFormat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, + "set_format".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_format" } + } + } + + val setLoopBegin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, + "set_loop_begin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_loop_begin" } + } + } + + val setLoopEnd: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, + "set_loop_end".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_loop_end" } + } + } + + val setLoopMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, + "set_loop_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_loop_mode" } + } + } + + val setMixRate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, + "set_mix_rate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mix_rate" } + } + } + + val setStereo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("AudioStreamSample".cstr.ptr, + "set_stereo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_stereo" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/BackBufferCopy.kt b/godot-kotlin/src/nativeGen/kotlin/godot/BackBufferCopy.kt index b7ad46f4..221be586 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/BackBufferCopy.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/BackBufferCopy.kt @@ -132,33 +132,41 @@ open class BackBufferCopy( * Container for method_bind pointers for BackBufferCopy */ private object __method_bind { - val getCopyMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BackBufferCopy".cstr.ptr, - "get_copy_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_copy_mode" } - } - val getRect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BackBufferCopy".cstr.ptr, - "get_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rect" } - } - val setCopyMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BackBufferCopy".cstr.ptr, - "set_copy_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_copy_mode" } - } - val setRect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BackBufferCopy".cstr.ptr, - "set_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rect" } - }} + val getCopyMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BackBufferCopy".cstr.ptr, + "get_copy_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_copy_mode" } + } + } + + val getRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BackBufferCopy".cstr.ptr, + "get_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rect" } + } + } + + val setCopyMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BackBufferCopy".cstr.ptr, + "set_copy_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_copy_mode" } + } + } + + val setRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BackBufferCopy".cstr.ptr, + "set_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rect" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/BakedLightmap.kt b/godot-kotlin/src/nativeGen/kotlin/godot/BakedLightmap.kt index 61da8eb6..f8a2dc4c 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/BakedLightmap.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/BakedLightmap.kt @@ -425,173 +425,223 @@ open class BakedLightmap( * Container for method_bind pointers for BakedLightmap */ private object __method_bind { - val bake: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "bake".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method bake" } - } - val debugBake: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "debug_bake".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method debug_bake" } - } - val getBakeCellSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "get_bake_cell_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bake_cell_size" } - } - val getBakeDefaultTexelsPerUnit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "get_bake_default_texels_per_unit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bake_default_texels_per_unit" } - } - val getBakeMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "get_bake_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bake_mode" } - } - val getBakeQuality: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "get_bake_quality".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bake_quality" } - } - val getCaptureCellSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "get_capture_cell_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_capture_cell_size" } - } - val getEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "get_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_energy" } - } - val getExtents: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "get_extents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_extents" } - } - val getImagePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "get_image_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_image_path" } - } - val getLightData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "get_light_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_light_data" } - } - val getPropagation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "get_propagation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_propagation" } - } - val isHdr: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "is_hdr".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_hdr" } - } - val setBakeCellSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "set_bake_cell_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bake_cell_size" } - } - val setBakeDefaultTexelsPerUnit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "set_bake_default_texels_per_unit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bake_default_texels_per_unit" } - } - val setBakeMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "set_bake_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bake_mode" } - } - val setBakeQuality: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "set_bake_quality".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bake_quality" } - } - val setCaptureCellSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "set_capture_cell_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_capture_cell_size" } - } - val setEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "set_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_energy" } - } - val setExtents: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "set_extents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_extents" } - } - val setHdr: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "set_hdr".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_hdr" } - } - val setImagePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "set_image_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_image_path" } - } - val setLightData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "set_light_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_light_data" } - } - val setPropagation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, - "set_propagation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_propagation" } - }} + val bake: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "bake".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method bake" } + } + } + + val debugBake: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "debug_bake".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method debug_bake" } + } + } + + val getBakeCellSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "get_bake_cell_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bake_cell_size" } + } + } + + val getBakeDefaultTexelsPerUnit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "get_bake_default_texels_per_unit".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_bake_default_texels_per_unit" } + } + } + + val getBakeMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "get_bake_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bake_mode" } + } + } + + val getBakeQuality: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "get_bake_quality".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bake_quality" } + } + } + + val getCaptureCellSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "get_capture_cell_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_capture_cell_size" } + } + } + + val getEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "get_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_energy" } + } + } + + val getExtents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "get_extents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_extents" } + } + } + + val getImagePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "get_image_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_image_path" } + } + } + + val getLightData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "get_light_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_light_data" } + } + } + + val getPropagation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "get_propagation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_propagation" } + } + } + + val isHdr: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "is_hdr".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_hdr" } + } + } + + val setBakeCellSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "set_bake_cell_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bake_cell_size" } + } + } + + val setBakeDefaultTexelsPerUnit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "set_bake_default_texels_per_unit".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_bake_default_texels_per_unit" } + } + } + + val setBakeMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "set_bake_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bake_mode" } + } + } + + val setBakeQuality: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "set_bake_quality".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bake_quality" } + } + } + + val setCaptureCellSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "set_capture_cell_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_capture_cell_size" } + } + } + + val setEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "set_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_energy" } + } + } + + val setExtents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "set_extents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_extents" } + } + } + + val setHdr: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "set_hdr".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_hdr" } + } + } + + val setImagePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "set_image_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_image_path" } + } + } + + val setLightData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "set_light_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_light_data" } + } + } + + val setPropagation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmap".cstr.ptr, + "set_propagation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_propagation" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/BakedLightmapData.kt b/godot-kotlin/src/nativeGen/kotlin/godot/BakedLightmapData.kt index 80e263e8..44a20d72 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/BakedLightmapData.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/BakedLightmapData.kt @@ -273,110 +273,140 @@ open class BakedLightmapData( * Container for method_bind pointers for BakedLightmapData */ private object __method_bind { - val addUser: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, - "add_user".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_user" } - } - val clearUsers: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, - "clear_users".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_users" } - } - val getBounds: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, - "get_bounds".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bounds" } - } - val getCellSpaceTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, - "get_cell_space_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cell_space_transform" } - } - val getCellSubdiv: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, - "get_cell_subdiv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cell_subdiv" } - } - val getEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, - "get_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_energy" } - } - val getOctree: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, - "get_octree".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_octree" } - } - val getUserCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, - "get_user_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_user_count" } - } - val getUserLightmap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, - "get_user_lightmap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_user_lightmap" } - } - val getUserPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, - "get_user_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_user_path" } - } - val setBounds: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, - "set_bounds".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bounds" } - } - val setCellSpaceTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, - "set_cell_space_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cell_space_transform" } - } - val setCellSubdiv: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, - "set_cell_subdiv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cell_subdiv" } - } - val setEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, - "set_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_energy" } - } - val setOctree: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, - "set_octree".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_octree" } - }} + val addUser: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, + "add_user".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_user" } + } + } + + val clearUsers: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, + "clear_users".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_users" } + } + } + + val getBounds: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, + "get_bounds".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bounds" } + } + } + + val getCellSpaceTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, + "get_cell_space_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cell_space_transform" } + } + } + + val getCellSubdiv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, + "get_cell_subdiv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cell_subdiv" } + } + } + + val getEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, + "get_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_energy" } + } + } + + val getOctree: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, + "get_octree".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_octree" } + } + } + + val getUserCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, + "get_user_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_user_count" } + } + } + + val getUserLightmap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, + "get_user_lightmap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_user_lightmap" } + } + } + + val getUserPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, + "get_user_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_user_path" } + } + } + + val setBounds: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, + "set_bounds".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bounds" } + } + } + + val setCellSpaceTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, + "set_cell_space_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cell_space_transform" } + } + } + + val setCellSubdiv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, + "set_cell_subdiv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cell_subdiv" } + } + } + + val setEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, + "set_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_energy" } + } + } + + val setOctree: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BakedLightmapData".cstr.ptr, + "set_octree".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_octree" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/BaseButton.kt b/godot-kotlin/src/nativeGen/kotlin/godot/BaseButton.kt index 743b5560..f5cefc2f 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/BaseButton.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/BaseButton.kt @@ -389,137 +389,204 @@ open class BaseButton( * Container for method_bind pointers for BaseButton */ private object __method_bind { - val getActionMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "get_action_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_action_mode" } - } - val getButtonGroup: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "get_button_group".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_button_group" } - } - val getButtonMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "get_button_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_button_mask" } - } - val getDrawMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "get_draw_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_draw_mode" } - } - val getEnabledFocusMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "get_enabled_focus_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_enabled_focus_mode" } - } - val getShortcut: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "get_shortcut".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shortcut" } - } - val isDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "is_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_disabled" } - } - val isHovered: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "is_hovered".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_hovered" } - } - val isKeepPressedOutside: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "is_keep_pressed_outside".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_keep_pressed_outside" } - } - val isPressed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "is_pressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_pressed" } - } - val isShortcutInTooltipEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "is_shortcut_in_tooltip_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_shortcut_in_tooltip_enabled" } - } - val isToggleMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "is_toggle_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_toggle_mode" } - } - val setActionMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "set_action_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_action_mode" } - } - val setButtonGroup: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "set_button_group".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_button_group" } - } - val setButtonMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "set_button_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_button_mask" } - } - val setDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "set_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_disabled" } - } - val setEnabledFocusMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "set_enabled_focus_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_enabled_focus_mode" } - } - val setKeepPressedOutside: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "set_keep_pressed_outside".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_keep_pressed_outside" } - } - val setPressed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "set_pressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pressed" } - } - val setShortcut: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "set_shortcut".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shortcut" } - } - val setShortcutInTooltip: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "set_shortcut_in_tooltip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shortcut_in_tooltip" } - } - val setToggleMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, - "set_toggle_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_toggle_mode" } - }} + val getActionMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "get_action_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_action_mode" } + } + } + + val getButtonGroup: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "get_button_group".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_button_group" } + } + } + + val getButtonMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "get_button_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_button_mask" } + } + } + + val getDrawMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "get_draw_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_draw_mode" } + } + } + + val getEnabledFocusMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "get_enabled_focus_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_enabled_focus_mode" } + } + } + + val getShortcut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "get_shortcut".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shortcut" } + } + } + + val isDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "is_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_disabled" } + } + } + + val isHovered: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "is_hovered".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_hovered" } + } + } + + val isKeepPressedOutside: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "is_keep_pressed_outside".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_keep_pressed_outside" } + } + } + + val isPressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "is_pressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_pressed" } + } + } + + val isShortcutInTooltipEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "is_shortcut_in_tooltip_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_shortcut_in_tooltip_enabled" + } + } + } + + val isToggleMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "is_toggle_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_toggle_mode" } + } + } + + val setActionMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "set_action_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_action_mode" } + } + } + + val setButtonGroup: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "set_button_group".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_button_group" } + } + } + + val setButtonMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "set_button_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_button_mask" } + } + } + + val setDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "set_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_disabled" } + } + } + + val setEnabledFocusMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "set_enabled_focus_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_enabled_focus_mode" } + } + } + + val setKeepPressedOutside: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "set_keep_pressed_outside".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_keep_pressed_outside" } + } + } + + val setPressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "set_pressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pressed" } + } + } + + val setShortcut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "set_shortcut".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shortcut" } + } + } + + val setShortcutInTooltip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "set_shortcut_in_tooltip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shortcut_in_tooltip" } + } + } + + val setToggleMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BaseButton".cstr.ptr, + "set_toggle_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_toggle_mode" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/BitMap.kt b/godot-kotlin/src/nativeGen/kotlin/godot/BitMap.kt index 34775807..78123deb 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/BitMap.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/BitMap.kt @@ -153,59 +153,77 @@ open class BitMap( * Container for method_bind pointers for BitMap */ private object __method_bind { - val create: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitMap".cstr.ptr, - "create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create" } - } - val createFromImageAlpha: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitMap".cstr.ptr, - "create_from_image_alpha".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_from_image_alpha" } - } - val getBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitMap".cstr.ptr, - "get_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bit" } - } - val getSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitMap".cstr.ptr, - "get_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_size" } - } - val getTrueBitCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitMap".cstr.ptr, - "get_true_bit_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_true_bit_count" } - } - val growMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitMap".cstr.ptr, - "grow_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method grow_mask" } - } - val opaqueToPolygons: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitMap".cstr.ptr, - "opaque_to_polygons".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method opaque_to_polygons" } - } - val setBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitMap".cstr.ptr, - "set_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bit" } - } - val setBitRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitMap".cstr.ptr, - "set_bit_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bit_rect" } - }} + val create: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitMap".cstr.ptr, + "create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create" } + } + } + + val createFromImageAlpha: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitMap".cstr.ptr, + "create_from_image_alpha".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_from_image_alpha" } + } + } + + val getBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitMap".cstr.ptr, + "get_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bit" } + } + } + + val getSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitMap".cstr.ptr, + "get_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_size" } + } + } + + val getTrueBitCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitMap".cstr.ptr, + "get_true_bit_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_true_bit_count" } + } + } + + val growMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitMap".cstr.ptr, + "grow_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method grow_mask" } + } + } + + val opaqueToPolygons: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitMap".cstr.ptr, + "opaque_to_polygons".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method opaque_to_polygons" } + } + } + + val setBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitMap".cstr.ptr, + "set_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bit" } + } + } + + val setBitRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitMap".cstr.ptr, + "set_bit_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bit_rect" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/BitmapFont.kt b/godot-kotlin/src/nativeGen/kotlin/godot/BitmapFont.kt index 1f973a8f..bb3f9740 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/BitmapFont.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/BitmapFont.kt @@ -257,89 +257,131 @@ open class BitmapFont( * Container for method_bind pointers for BitmapFont */ private object __method_bind { - val addChar: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, - "add_char".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_char" } - } - val addKerningPair: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, - "add_kerning_pair".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_kerning_pair" } - } - val addTexture: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, - "add_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_texture" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val createFromFnt: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, - "create_from_fnt".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_from_fnt" } - } - val getCharSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, - "get_char_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_char_size" } - } - val getFallback: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, - "get_fallback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fallback" } - } - val getKerningPair: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, - "get_kerning_pair".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_kerning_pair" } - } - val getTexture: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, - "get_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture" } - } - val getTextureCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, - "get_texture_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture_count" } - } - val setAscent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, - "set_ascent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ascent" } - } - val setDistanceFieldHint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, - "set_distance_field_hint".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_distance_field_hint" } - } - val setFallback: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, - "set_fallback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fallback" } - } - val setHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, - "set_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_height" } - }} + val addChar: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, + "add_char".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_char" } + } + } + + val addKerningPair: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, + "add_kerning_pair".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_kerning_pair" } + } + } + + val addTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, + "add_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_texture" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val createFromFnt: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, + "create_from_fnt".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_from_fnt" } + } + } + + val getCharSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, + "get_char_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_char_size" } + } + } + + val getFallback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, + "get_fallback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fallback" } + } + } + + val getKerningPair: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, + "get_kerning_pair".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_kerning_pair" } + } + } + + val getTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, + "get_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture" } + } + } + + val getTextureCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, + "get_texture_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture_count" } + } + } + + val setAscent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, + "set_ascent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ascent" } + } + } + + val setDistanceFieldHint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, + "set_distance_field_hint".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_distance_field_hint" } + } + } + + val setFallback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, + "set_fallback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fallback" } + } + } + + val setHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BitmapFont".cstr.ptr, + "set_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_height" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Bone2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Bone2D.kt index 85b0fa43..1cba8b48 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Bone2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Bone2D.kt @@ -139,47 +139,61 @@ open class Bone2D( * Container for method_bind pointers for Bone2D */ private object __method_bind { - val applyRest: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Bone2D".cstr.ptr, - "apply_rest".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method apply_rest" } - } - val getDefaultLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Bone2D".cstr.ptr, - "get_default_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_default_length" } - } - val getIndexInSkeleton: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Bone2D".cstr.ptr, - "get_index_in_skeleton".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_index_in_skeleton" } - } - val getRest: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Bone2D".cstr.ptr, - "get_rest".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rest" } - } - val getSkeletonRest: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Bone2D".cstr.ptr, - "get_skeleton_rest".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_skeleton_rest" } - } - val setDefaultLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Bone2D".cstr.ptr, - "set_default_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_default_length" } - } - val setRest: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Bone2D".cstr.ptr, - "set_rest".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rest" } - }} + val applyRest: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Bone2D".cstr.ptr, + "apply_rest".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method apply_rest" } + } + } + + val getDefaultLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Bone2D".cstr.ptr, + "get_default_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_default_length" } + } + } + + val getIndexInSkeleton: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Bone2D".cstr.ptr, + "get_index_in_skeleton".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_index_in_skeleton" } + } + } + + val getRest: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Bone2D".cstr.ptr, + "get_rest".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rest" } + } + } + + val getSkeletonRest: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Bone2D".cstr.ptr, + "get_skeleton_rest".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_skeleton_rest" } + } + } + + val setDefaultLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Bone2D".cstr.ptr, + "set_default_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_default_length" } + } + } + + val setRest: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Bone2D".cstr.ptr, + "set_rest".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rest" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/BoneAttachment.kt b/godot-kotlin/src/nativeGen/kotlin/godot/BoneAttachment.kt index 02e4975a..aafd867d 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/BoneAttachment.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/BoneAttachment.kt @@ -74,19 +74,23 @@ open class BoneAttachment( * Container for method_bind pointers for BoneAttachment */ private object __method_bind { - val getBoneName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BoneAttachment".cstr.ptr, - "get_bone_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bone_name" } - } - val setBoneName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BoneAttachment".cstr.ptr, - "set_bone_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bone_name" } - }} + val getBoneName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BoneAttachment".cstr.ptr, + "get_bone_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bone_name" } + } + } + + val setBoneName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BoneAttachment".cstr.ptr, + "set_bone_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bone_name" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/BoxContainer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/BoxContainer.kt index de3d592f..2dbf2e79 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/BoxContainer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/BoxContainer.kt @@ -96,26 +96,32 @@ open class BoxContainer( * Container for method_bind pointers for BoxContainer */ private object __method_bind { - val addSpacer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BoxContainer".cstr.ptr, - "add_spacer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_spacer" } - } - val getAlignment: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BoxContainer".cstr.ptr, - "get_alignment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_alignment" } - } - val setAlignment: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BoxContainer".cstr.ptr, - "set_alignment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_alignment" } - }} + val addSpacer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BoxContainer".cstr.ptr, + "add_spacer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_spacer" } + } + } + + val getAlignment: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BoxContainer".cstr.ptr, + "get_alignment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_alignment" } + } + } + + val setAlignment: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BoxContainer".cstr.ptr, + "set_alignment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_alignment" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/BoxShape.kt b/godot-kotlin/src/nativeGen/kotlin/godot/BoxShape.kt index 31ad4303..993af747 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/BoxShape.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/BoxShape.kt @@ -84,17 +84,23 @@ open class BoxShape( * Container for method_bind pointers for BoxShape */ private object __method_bind { - val getExtents: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BoxShape".cstr.ptr, - "get_extents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_extents" } - } - val setExtents: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BoxShape".cstr.ptr, - "set_extents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_extents" } - }} + val getExtents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BoxShape".cstr.ptr, + "get_extents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_extents" } + } + } + + val setExtents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("BoxShape".cstr.ptr, + "set_extents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_extents" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Button.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Button.kt index bbabf99c..0df23ec6 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Button.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Button.kt @@ -223,77 +223,101 @@ open class Button( * Container for method_bind pointers for Button */ private object __method_bind { - val getButtonIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, - "get_button_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_button_icon" } - } - val getClipText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, - "get_clip_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_clip_text" } - } - val getText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, - "get_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_text" } - } - val getTextAlign: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, - "get_text_align".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_text_align" } - } - val isExpandIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, - "is_expand_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_expand_icon" } - } - val isFlat: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, - "is_flat".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_flat" } - } - val setButtonIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, - "set_button_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_button_icon" } - } - val setClipText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, - "set_clip_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_clip_text" } - } - val setExpandIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, - "set_expand_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_expand_icon" } - } - val setFlat: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, - "set_flat".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flat" } - } - val setText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, - "set_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_text" } - } - val setTextAlign: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, - "set_text_align".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_text_align" } - }} + val getButtonIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, + "get_button_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_button_icon" } + } + } + + val getClipText: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, + "get_clip_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_clip_text" } + } + } + + val getText: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, + "get_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_text" } + } + } + + val getTextAlign: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, + "get_text_align".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_text_align" } + } + } + + val isExpandIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, + "is_expand_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_expand_icon" } + } + } + + val isFlat: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, + "is_flat".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_flat" } + } + } + + val setButtonIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, + "set_button_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_button_icon" } + } + } + + val setClipText: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, + "set_clip_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_clip_text" } + } + } + + val setExpandIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, + "set_expand_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_expand_icon" } + } + } + + val setFlat: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, + "set_flat".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flat" } + } + } + + val setText: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, + "set_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_text" } + } + } + + val setTextAlign: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Button".cstr.ptr, + "set_text_align".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_text_align" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ButtonGroup.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ButtonGroup.kt index 5a902279..a204c6ef 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ButtonGroup.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ButtonGroup.kt @@ -70,19 +70,23 @@ open class ButtonGroup( * Container for method_bind pointers for ButtonGroup */ private object __method_bind { - val getButtons: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ButtonGroup".cstr.ptr, - "get_buttons".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_buttons" } - } - val getPressedButton: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ButtonGroup".cstr.ptr, - "get_pressed_button".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pressed_button" } - }} + val getButtons: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ButtonGroup".cstr.ptr, + "get_buttons".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_buttons" } + } + } + + val getPressedButton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ButtonGroup".cstr.ptr, + "get_pressed_button".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pressed_button" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CPUParticles.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CPUParticles.kt index 8b9b222d..278d8413 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CPUParticles.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CPUParticles.kt @@ -1295,439 +1295,563 @@ open class CPUParticles( * Container for method_bind pointers for CPUParticles */ private object __method_bind { - val convertFromParticles: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "convert_from_particles".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method convert_from_particles" } - } - val getAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_amount" } - } - val getColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_color" } - } - val getColorRamp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_color_ramp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_color_ramp" } - } - val getDirection: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_direction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_direction" } - } - val getDrawOrder: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_draw_order".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_draw_order" } - } - val getEmissionBoxExtents: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_emission_box_extents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_box_extents" } - } - val getEmissionColors: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_emission_colors".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_colors" } - } - val getEmissionNormals: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_emission_normals".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_normals" } - } - val getEmissionPoints: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_emission_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_points" } - } - val getEmissionShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_emission_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_shape" } - } - val getEmissionSphereRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_emission_sphere_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_sphere_radius" } - } - val getExplosivenessRatio: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_explosiveness_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_explosiveness_ratio" } - } - val getFixedFps: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_fixed_fps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fixed_fps" } - } - val getFlatness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_flatness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_flatness" } - } - val getFractionalDelta: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_fractional_delta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fractional_delta" } - } - val getGravity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_gravity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gravity" } - } - val getLifetime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_lifetime".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_lifetime" } - } - val getLifetimeRandomness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_lifetime_randomness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_lifetime_randomness" } - } - val getMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mesh" } - } - val getOneShot: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_one_shot".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_one_shot" } - } - val getParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_param" } - } - val getParamCurve: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_param_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_param_curve" } - } - val getParamRandomness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_param_randomness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_param_randomness" } - } - val getParticleFlag: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_particle_flag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_particle_flag" } - } - val getPreProcessTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_pre_process_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pre_process_time" } - } - val getRandomnessRatio: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_randomness_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_randomness_ratio" } - } - val getSpeedScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_speed_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_speed_scale" } - } - val getSpread: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_spread".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_spread" } - } - val getUseLocalCoordinates: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "get_use_local_coordinates".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_use_local_coordinates" } - } - val isEmitting: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "is_emitting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_emitting" } - } - val restart: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "restart".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method restart" } - } - val setAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_amount" } - } - val setColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_color" } - } - val setColorRamp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_color_ramp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_color_ramp" } - } - val setDirection: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_direction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_direction" } - } - val setDrawOrder: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_draw_order".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_draw_order" } - } - val setEmissionBoxExtents: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_emission_box_extents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_box_extents" } - } - val setEmissionColors: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_emission_colors".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_colors" } - } - val setEmissionNormals: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_emission_normals".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_normals" } - } - val setEmissionPoints: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_emission_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_points" } - } - val setEmissionShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_emission_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_shape" } - } - val setEmissionSphereRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_emission_sphere_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_sphere_radius" } - } - val setEmitting: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_emitting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emitting" } - } - val setExplosivenessRatio: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_explosiveness_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_explosiveness_ratio" } - } - val setFixedFps: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_fixed_fps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fixed_fps" } - } - val setFlatness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_flatness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flatness" } - } - val setFractionalDelta: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_fractional_delta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fractional_delta" } - } - val setGravity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_gravity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_gravity" } - } - val setLifetime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_lifetime".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_lifetime" } - } - val setLifetimeRandomness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_lifetime_randomness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_lifetime_randomness" } - } - val setMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mesh" } - } - val setOneShot: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_one_shot".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_one_shot" } - } - val setParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_param" } - } - val setParamCurve: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_param_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_param_curve" } - } - val setParamRandomness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_param_randomness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_param_randomness" } - } - val setParticleFlag: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_particle_flag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_particle_flag" } - } - val setPreProcessTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_pre_process_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pre_process_time" } - } - val setRandomnessRatio: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_randomness_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_randomness_ratio" } - } - val setSpeedScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_speed_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_speed_scale" } - } - val setSpread: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_spread".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_spread" } - } - val setUseLocalCoordinates: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, - "set_use_local_coordinates".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_local_coordinates" } - }} + val convertFromParticles: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "convert_from_particles".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method convert_from_particles" } + } + } + + val getAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_amount" } + } + } + + val getColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_color" } + } + } + + val getColorRamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_color_ramp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_color_ramp" } + } + } + + val getDirection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_direction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_direction" } + } + } + + val getDrawOrder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_draw_order".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_draw_order" } + } + } + + val getEmissionBoxExtents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_emission_box_extents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_box_extents" } + } + } + + val getEmissionColors: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_emission_colors".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_colors" } + } + } + + val getEmissionNormals: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_emission_normals".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_normals" } + } + } + + val getEmissionPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_emission_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_points" } + } + } + + val getEmissionShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_emission_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_shape" } + } + } + + val getEmissionSphereRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_emission_sphere_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_sphere_radius" } + } + } + + val getExplosivenessRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_explosiveness_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_explosiveness_ratio" } + } + } + + val getFixedFps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_fixed_fps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fixed_fps" } + } + } + + val getFlatness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_flatness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_flatness" } + } + } + + val getFractionalDelta: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_fractional_delta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fractional_delta" } + } + } + + val getGravity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_gravity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gravity" } + } + } + + val getLifetime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_lifetime".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_lifetime" } + } + } + + val getLifetimeRandomness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_lifetime_randomness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_lifetime_randomness" } + } + } + + val getMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mesh" } + } + } + + val getOneShot: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_one_shot".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_one_shot" } + } + } + + val getParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_param" } + } + } + + val getParamCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_param_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_param_curve" } + } + } + + val getParamRandomness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_param_randomness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_param_randomness" } + } + } + + val getParticleFlag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_particle_flag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_particle_flag" } + } + } + + val getPreProcessTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_pre_process_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pre_process_time" } + } + } + + val getRandomnessRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_randomness_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_randomness_ratio" } + } + } + + val getSpeedScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_speed_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_speed_scale" } + } + } + + val getSpread: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_spread".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_spread" } + } + } + + val getUseLocalCoordinates: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "get_use_local_coordinates".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_use_local_coordinates" } + } + } + + val isEmitting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "is_emitting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_emitting" } + } + } + + val restart: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "restart".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method restart" } + } + } + + val setAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_amount" } + } + } + + val setColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_color" } + } + } + + val setColorRamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_color_ramp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_color_ramp" } + } + } + + val setDirection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_direction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_direction" } + } + } + + val setDrawOrder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_draw_order".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_draw_order" } + } + } + + val setEmissionBoxExtents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_emission_box_extents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_box_extents" } + } + } + + val setEmissionColors: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_emission_colors".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_colors" } + } + } + + val setEmissionNormals: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_emission_normals".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_normals" } + } + } + + val setEmissionPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_emission_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_points" } + } + } + + val setEmissionShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_emission_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_shape" } + } + } + + val setEmissionSphereRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_emission_sphere_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_sphere_radius" } + } + } + + val setEmitting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_emitting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emitting" } + } + } + + val setExplosivenessRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_explosiveness_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_explosiveness_ratio" } + } + } + + val setFixedFps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_fixed_fps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fixed_fps" } + } + } + + val setFlatness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_flatness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flatness" } + } + } + + val setFractionalDelta: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_fractional_delta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fractional_delta" } + } + } + + val setGravity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_gravity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_gravity" } + } + } + + val setLifetime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_lifetime".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_lifetime" } + } + } + + val setLifetimeRandomness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_lifetime_randomness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_lifetime_randomness" } + } + } + + val setMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mesh" } + } + } + + val setOneShot: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_one_shot".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_one_shot" } + } + } + + val setParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_param" } + } + } + + val setParamCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_param_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_param_curve" } + } + } + + val setParamRandomness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_param_randomness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_param_randomness" } + } + } + + val setParticleFlag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_particle_flag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_particle_flag" } + } + } + + val setPreProcessTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_pre_process_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pre_process_time" } + } + } + + val setRandomnessRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_randomness_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_randomness_ratio" } + } + } + + val setSpeedScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_speed_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_speed_scale" } + } + } + + val setSpread: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_spread".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_spread" } + } + } + + val setUseLocalCoordinates: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles".cstr.ptr, + "set_use_local_coordinates".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_local_coordinates" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CPUParticles2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CPUParticles2D.kt index 94d0ba96..4b140d21 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CPUParticles2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CPUParticles2D.kt @@ -1280,439 +1280,563 @@ open class CPUParticles2D( * Container for method_bind pointers for CPUParticles2D */ private object __method_bind { - val convertFromParticles: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "convert_from_particles".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method convert_from_particles" } - } - val getAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_amount" } - } - val getColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_color" } - } - val getColorRamp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_color_ramp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_color_ramp" } - } - val getDirection: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_direction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_direction" } - } - val getDrawOrder: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_draw_order".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_draw_order" } - } - val getEmissionColors: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_emission_colors".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_colors" } - } - val getEmissionNormals: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_emission_normals".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_normals" } - } - val getEmissionPoints: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_emission_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_points" } - } - val getEmissionRectExtents: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_emission_rect_extents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_rect_extents" } - } - val getEmissionShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_emission_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_shape" } - } - val getEmissionSphereRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_emission_sphere_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_sphere_radius" } - } - val getExplosivenessRatio: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_explosiveness_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_explosiveness_ratio" } - } - val getFixedFps: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_fixed_fps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fixed_fps" } - } - val getFractionalDelta: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_fractional_delta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fractional_delta" } - } - val getGravity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_gravity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gravity" } - } - val getLifetime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_lifetime".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_lifetime" } - } - val getLifetimeRandomness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_lifetime_randomness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_lifetime_randomness" } - } - val getNormalmap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_normalmap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_normalmap" } - } - val getOneShot: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_one_shot".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_one_shot" } - } - val getParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_param" } - } - val getParamCurve: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_param_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_param_curve" } - } - val getParamRandomness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_param_randomness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_param_randomness" } - } - val getParticleFlag: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_particle_flag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_particle_flag" } - } - val getPreProcessTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_pre_process_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pre_process_time" } - } - val getRandomnessRatio: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_randomness_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_randomness_ratio" } - } - val getSpeedScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_speed_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_speed_scale" } - } - val getSpread: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_spread".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_spread" } - } - val getTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture" } - } - val getUseLocalCoordinates: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "get_use_local_coordinates".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_use_local_coordinates" } - } - val isEmitting: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "is_emitting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_emitting" } - } - val restart: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "restart".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method restart" } - } - val setAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_amount" } - } - val setColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_color" } - } - val setColorRamp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_color_ramp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_color_ramp" } - } - val setDirection: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_direction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_direction" } - } - val setDrawOrder: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_draw_order".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_draw_order" } - } - val setEmissionColors: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_emission_colors".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_colors" } - } - val setEmissionNormals: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_emission_normals".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_normals" } - } - val setEmissionPoints: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_emission_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_points" } - } - val setEmissionRectExtents: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_emission_rect_extents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_rect_extents" } - } - val setEmissionShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_emission_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_shape" } - } - val setEmissionSphereRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_emission_sphere_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_sphere_radius" } - } - val setEmitting: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_emitting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emitting" } - } - val setExplosivenessRatio: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_explosiveness_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_explosiveness_ratio" } - } - val setFixedFps: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_fixed_fps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fixed_fps" } - } - val setFractionalDelta: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_fractional_delta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fractional_delta" } - } - val setGravity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_gravity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_gravity" } - } - val setLifetime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_lifetime".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_lifetime" } - } - val setLifetimeRandomness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_lifetime_randomness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_lifetime_randomness" } - } - val setNormalmap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_normalmap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_normalmap" } - } - val setOneShot: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_one_shot".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_one_shot" } - } - val setParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_param" } - } - val setParamCurve: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_param_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_param_curve" } - } - val setParamRandomness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_param_randomness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_param_randomness" } - } - val setParticleFlag: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_particle_flag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_particle_flag" } - } - val setPreProcessTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_pre_process_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pre_process_time" } - } - val setRandomnessRatio: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_randomness_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_randomness_ratio" } - } - val setSpeedScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_speed_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_speed_scale" } - } - val setSpread: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_spread".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_spread" } - } - val setTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture" } - } - val setUseLocalCoordinates: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, - "set_use_local_coordinates".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_local_coordinates" } - }} + val convertFromParticles: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "convert_from_particles".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method convert_from_particles" } + } + } + + val getAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_amount" } + } + } + + val getColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_color" } + } + } + + val getColorRamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_color_ramp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_color_ramp" } + } + } + + val getDirection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_direction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_direction" } + } + } + + val getDrawOrder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_draw_order".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_draw_order" } + } + } + + val getEmissionColors: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_emission_colors".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_colors" } + } + } + + val getEmissionNormals: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_emission_normals".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_normals" } + } + } + + val getEmissionPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_emission_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_points" } + } + } + + val getEmissionRectExtents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_emission_rect_extents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_rect_extents" } + } + } + + val getEmissionShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_emission_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_shape" } + } + } + + val getEmissionSphereRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_emission_sphere_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_sphere_radius" } + } + } + + val getExplosivenessRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_explosiveness_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_explosiveness_ratio" } + } + } + + val getFixedFps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_fixed_fps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fixed_fps" } + } + } + + val getFractionalDelta: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_fractional_delta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fractional_delta" } + } + } + + val getGravity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_gravity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gravity" } + } + } + + val getLifetime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_lifetime".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_lifetime" } + } + } + + val getLifetimeRandomness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_lifetime_randomness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_lifetime_randomness" } + } + } + + val getNormalmap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_normalmap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_normalmap" } + } + } + + val getOneShot: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_one_shot".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_one_shot" } + } + } + + val getParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_param" } + } + } + + val getParamCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_param_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_param_curve" } + } + } + + val getParamRandomness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_param_randomness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_param_randomness" } + } + } + + val getParticleFlag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_particle_flag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_particle_flag" } + } + } + + val getPreProcessTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_pre_process_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pre_process_time" } + } + } + + val getRandomnessRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_randomness_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_randomness_ratio" } + } + } + + val getSpeedScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_speed_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_speed_scale" } + } + } + + val getSpread: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_spread".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_spread" } + } + } + + val getTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture" } + } + } + + val getUseLocalCoordinates: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "get_use_local_coordinates".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_use_local_coordinates" } + } + } + + val isEmitting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "is_emitting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_emitting" } + } + } + + val restart: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "restart".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method restart" } + } + } + + val setAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_amount" } + } + } + + val setColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_color" } + } + } + + val setColorRamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_color_ramp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_color_ramp" } + } + } + + val setDirection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_direction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_direction" } + } + } + + val setDrawOrder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_draw_order".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_draw_order" } + } + } + + val setEmissionColors: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_emission_colors".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_colors" } + } + } + + val setEmissionNormals: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_emission_normals".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_normals" } + } + } + + val setEmissionPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_emission_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_points" } + } + } + + val setEmissionRectExtents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_emission_rect_extents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_rect_extents" } + } + } + + val setEmissionShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_emission_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_shape" } + } + } + + val setEmissionSphereRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_emission_sphere_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_sphere_radius" } + } + } + + val setEmitting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_emitting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emitting" } + } + } + + val setExplosivenessRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_explosiveness_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_explosiveness_ratio" } + } + } + + val setFixedFps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_fixed_fps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fixed_fps" } + } + } + + val setFractionalDelta: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_fractional_delta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fractional_delta" } + } + } + + val setGravity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_gravity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_gravity" } + } + } + + val setLifetime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_lifetime".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_lifetime" } + } + } + + val setLifetimeRandomness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_lifetime_randomness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_lifetime_randomness" } + } + } + + val setNormalmap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_normalmap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_normalmap" } + } + } + + val setOneShot: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_one_shot".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_one_shot" } + } + } + + val setParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_param" } + } + } + + val setParamCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_param_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_param_curve" } + } + } + + val setParamRandomness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_param_randomness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_param_randomness" } + } + } + + val setParticleFlag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_particle_flag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_particle_flag" } + } + } + + val setPreProcessTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_pre_process_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pre_process_time" } + } + } + + val setRandomnessRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_randomness_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_randomness_ratio" } + } + } + + val setSpeedScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_speed_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_speed_scale" } + } + } + + val setSpread: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_spread".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_spread" } + } + } + + val setTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture" } + } + } + + val setUseLocalCoordinates: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CPUParticles2D".cstr.ptr, + "set_use_local_coordinates".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_local_coordinates" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CSGBox.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CSGBox.kt index b4f0afc7..5313ae87 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CSGBox.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CSGBox.kt @@ -150,53 +150,69 @@ open class CSGBox( * Container for method_bind pointers for CSGBox */ private object __method_bind { - val getDepth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGBox".cstr.ptr, - "get_depth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_depth" } - } - val getHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGBox".cstr.ptr, - "get_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_height" } - } - val getMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGBox".cstr.ptr, - "get_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_material" } - } - val getWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGBox".cstr.ptr, - "get_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_width" } - } - val setDepth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGBox".cstr.ptr, - "set_depth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_depth" } - } - val setHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGBox".cstr.ptr, - "set_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_height" } - } - val setMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGBox".cstr.ptr, - "set_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_material" } - } - val setWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGBox".cstr.ptr, - "set_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_width" } - }} + val getDepth: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGBox".cstr.ptr, + "get_depth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_depth" } + } + } + + val getHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGBox".cstr.ptr, + "get_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_height" } + } + } + + val getMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGBox".cstr.ptr, + "get_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_material" } + } + } + + val getWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGBox".cstr.ptr, + "get_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_width" } + } + } + + val setDepth: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGBox".cstr.ptr, + "set_depth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_depth" } + } + } + + val setHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGBox".cstr.ptr, + "set_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_height" } + } + } + + val setMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGBox".cstr.ptr, + "set_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_material" } + } + } + + val setWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGBox".cstr.ptr, + "set_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_width" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CSGCylinder.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CSGCylinder.kt index 3342a6a9..af5714ad 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CSGCylinder.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CSGCylinder.kt @@ -202,89 +202,113 @@ open class CSGCylinder( * Container for method_bind pointers for CSGCylinder */ private object __method_bind { - val getHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, - "get_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_height" } - } - val getMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, - "get_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_material" } - } - val getRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, - "get_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_radius" } - } - val getSides: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, - "get_sides".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sides" } - } - val getSmoothFaces: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, - "get_smooth_faces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_smooth_faces" } - } - val isCone: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, - "is_cone".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_cone" } - } - val setCone: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, - "set_cone".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cone" } - } - val setHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, - "set_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_height" } - } - val setMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, - "set_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_material" } - } - val setRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, - "set_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_radius" } - } - val setSides: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, - "set_sides".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sides" } - } - val setSmoothFaces: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, - "set_smooth_faces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_smooth_faces" } - }} + val getHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, + "get_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_height" } + } + } + + val getMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, + "get_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_material" } + } + } + + val getRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, + "get_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_radius" } + } + } + + val getSides: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, + "get_sides".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sides" } + } + } + + val getSmoothFaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, + "get_smooth_faces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_smooth_faces" } + } + } + + val isCone: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, + "is_cone".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_cone" } + } + } + + val setCone: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, + "set_cone".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cone" } + } + } + + val setHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, + "set_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_height" } + } + } + + val setMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, + "set_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_material" } + } + } + + val setRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, + "set_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_radius" } + } + } + + val setSides: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, + "set_sides".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sides" } + } + } + + val setSmoothFaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGCylinder".cstr.ptr, + "set_smooth_faces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_smooth_faces" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CSGMesh.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CSGMesh.kt index 0bd94be6..fa730958 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CSGMesh.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CSGMesh.kt @@ -105,29 +105,41 @@ open class CSGMesh( * Container for method_bind pointers for CSGMesh */ private object __method_bind { - val getMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGMesh".cstr.ptr, - "get_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_material" } - } - val getMesh: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGMesh".cstr.ptr, - "get_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mesh" } - } - val setMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGMesh".cstr.ptr, - "set_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_material" } - } - val setMesh: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGMesh".cstr.ptr, - "set_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mesh" } - }} + val getMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGMesh".cstr.ptr, + "get_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_material" } + } + } + + val getMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGMesh".cstr.ptr, + "get_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mesh" } + } + } + + val setMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGMesh".cstr.ptr, + "set_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_material" } + } + } + + val setMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGMesh".cstr.ptr, + "set_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mesh" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CSGPolygon.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CSGPolygon.kt index aa23afd6..dc4b0b56 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CSGPolygon.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CSGPolygon.kt @@ -458,161 +458,239 @@ open class CSGPolygon( * Container for method_bind pointers for CSGPolygon */ private object __method_bind { - val getDepth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "get_depth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_depth" } - } - val getMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "get_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_material" } - } - val getMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "get_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mode" } - } - val getPathInterval: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "get_path_interval".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_path_interval" } - } - val getPathNode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "get_path_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_path_node" } - } - val getPathRotation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "get_path_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_path_rotation" } - } - val getPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "get_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_polygon" } - } - val getSmoothFaces: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "get_smooth_faces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_smooth_faces" } - } - val getSpinDegrees: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "get_spin_degrees".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_spin_degrees" } - } - val getSpinSides: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "get_spin_sides".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_spin_sides" } - } - val isPathContinuousU: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "is_path_continuous_u".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_path_continuous_u" } - } - val isPathJoined: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "is_path_joined".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_path_joined" } - } - val isPathLocal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "is_path_local".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_path_local" } - } - val setDepth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "set_depth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_depth" } - } - val setMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "set_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_material" } - } - val setMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "set_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mode" } - } - val setPathContinuousU: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "set_path_continuous_u".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_path_continuous_u" } - } - val setPathInterval: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "set_path_interval".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_path_interval" } - } - val setPathJoined: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "set_path_joined".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_path_joined" } - } - val setPathLocal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "set_path_local".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_path_local" } - } - val setPathNode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "set_path_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_path_node" } - } - val setPathRotation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "set_path_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_path_rotation" } - } - val setPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "set_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_polygon" } - } - val setSmoothFaces: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "set_smooth_faces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_smooth_faces" } - } - val setSpinDegrees: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "set_spin_degrees".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_spin_degrees" } - } - val setSpinSides: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, - "set_spin_sides".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_spin_sides" } - }} + val getDepth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "get_depth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_depth" } + } + } + + val getMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "get_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_material" } + } + } + + val getMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "get_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mode" } + } + } + + val getPathInterval: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "get_path_interval".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_path_interval" } + } + } + + val getPathNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "get_path_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_path_node" } + } + } + + val getPathRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "get_path_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_path_rotation" } + } + } + + val getPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "get_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_polygon" } + } + } + + val getSmoothFaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "get_smooth_faces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_smooth_faces" } + } + } + + val getSpinDegrees: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "get_spin_degrees".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_spin_degrees" } + } + } + + val getSpinSides: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "get_spin_sides".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_spin_sides" } + } + } + + val isPathContinuousU: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "is_path_continuous_u".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_path_continuous_u" } + } + } + + val isPathJoined: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "is_path_joined".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_path_joined" } + } + } + + val isPathLocal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "is_path_local".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_path_local" } + } + } + + val setDepth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "set_depth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_depth" } + } + } + + val setMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "set_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_material" } + } + } + + val setMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "set_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mode" } + } + } + + val setPathContinuousU: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "set_path_continuous_u".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_path_continuous_u" } + } + } + + val setPathInterval: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "set_path_interval".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_path_interval" } + } + } + + val setPathJoined: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "set_path_joined".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_path_joined" } + } + } + + val setPathLocal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "set_path_local".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_path_local" } + } + } + + val setPathNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "set_path_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_path_node" } + } + } + + val setPathRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "set_path_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_path_rotation" } + } + } + + val setPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "set_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_polygon" } + } + } + + val setSmoothFaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "set_smooth_faces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_smooth_faces" } + } + } + + val setSpinDegrees: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "set_spin_degrees".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_spin_degrees" } + } + } + + val setSpinSides: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPolygon".cstr.ptr, + "set_spin_sides".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_spin_sides" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CSGPrimitive.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CSGPrimitive.kt index 6ab1b628..03aa5035 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CSGPrimitive.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CSGPrimitive.kt @@ -67,19 +67,23 @@ open class CSGPrimitive( * Container for method_bind pointers for CSGPrimitive */ private object __method_bind { - val isInvertingFaces: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPrimitive".cstr.ptr, - "is_inverting_faces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_inverting_faces" } - } - val setInvertFaces: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPrimitive".cstr.ptr, - "set_invert_faces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_invert_faces" } - }} + val isInvertingFaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPrimitive".cstr.ptr, + "is_inverting_faces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_inverting_faces" } + } + } + + val setInvertFaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGPrimitive".cstr.ptr, + "set_invert_faces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_invert_faces" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CSGShape.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CSGShape.kt index e89c2edf..ae6b9895 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CSGShape.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CSGShape.kt @@ -280,113 +280,167 @@ open class CSGShape( * Container for method_bind pointers for CSGShape */ private object __method_bind { - val getCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, - "get_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_layer" } - } - val getCollisionLayerBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, - "get_collision_layer_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_layer_bit" } - } - val getCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, - "get_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } - } - val getCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, - "get_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } - } - val getMeshes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, - "get_meshes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_meshes" } - } - val getOperation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, - "get_operation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_operation" } - } - val getSnap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, - "get_snap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_snap" } - } - val isCalculatingTangents: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, - "is_calculating_tangents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_calculating_tangents" } - } - val isRootShape: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, - "is_root_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_root_shape" } - } - val isUsingCollision: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, - "is_using_collision".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_using_collision" } - } - val setCalculateTangents: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, - "set_calculate_tangents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_calculate_tangents" } - } - val setCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, - "set_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_layer" } - } - val setCollisionLayerBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, - "set_collision_layer_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_layer_bit" } - } - val setCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, - "set_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } - } - val setCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, - "set_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } - } - val setOperation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, - "set_operation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_operation" } - } - val setSnap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, - "set_snap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_snap" } - } - val setUseCollision: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, - "set_use_collision".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_collision" } - }} + val getCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, + "get_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_layer" } + } + } + + val getCollisionLayerBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, + "get_collision_layer_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_layer_bit" } + } + } + + val getCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, + "get_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } + } + } + + val getCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, + "get_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } + } + } + + val getMeshes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, + "get_meshes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_meshes" } + } + } + + val getOperation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, + "get_operation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_operation" } + } + } + + val getSnap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, + "get_snap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_snap" } + } + } + + val isCalculatingTangents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, + "is_calculating_tangents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_calculating_tangents" } + } + } + + val isRootShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, + "is_root_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_root_shape" } + } + } + + val isUsingCollision: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, + "is_using_collision".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_using_collision" } + } + } + + val setCalculateTangents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, + "set_calculate_tangents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_calculate_tangents" } + } + } + + val setCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, + "set_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_layer" } + } + } + + val setCollisionLayerBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, + "set_collision_layer_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_layer_bit" } + } + } + + val setCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, + "set_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } + } + } + + val setCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, + "set_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } + } + } + + val setOperation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, + "set_operation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_operation" } + } + } + + val setSnap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, + "set_snap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_snap" } + } + } + + val setUseCollision: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGShape".cstr.ptr, + "set_use_collision".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_collision" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CSGSphere.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CSGSphere.kt index a8f5311b..f09fbdb6 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CSGSphere.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CSGSphere.kt @@ -177,65 +177,95 @@ open class CSGSphere( * Container for method_bind pointers for CSGSphere */ private object __method_bind { - val getMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, - "get_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_material" } - } - val getRadialSegments: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, - "get_radial_segments".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_radial_segments" } - } - val getRadius: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, - "get_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_radius" } - } - val getRings: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, - "get_rings".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rings" } - } - val getSmoothFaces: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, - "get_smooth_faces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_smooth_faces" } - } - val setMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, - "set_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_material" } - } - val setRadialSegments: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, - "set_radial_segments".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_radial_segments" } - } - val setRadius: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, - "set_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_radius" } - } - val setRings: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, - "set_rings".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rings" } - } - val setSmoothFaces: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, - "set_smooth_faces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_smooth_faces" } - }} + val getMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, + "get_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_material" } + } + } + + val getRadialSegments: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, + "get_radial_segments".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_radial_segments" } + } + } + + val getRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, + "get_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_radius" } + } + } + + val getRings: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, + "get_rings".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rings" } + } + } + + val getSmoothFaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, + "get_smooth_faces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_smooth_faces" } + } + } + + val setMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, + "set_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_material" } + } + } + + val setRadialSegments: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, + "set_radial_segments".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_radial_segments" } + } + } + + val setRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, + "set_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_radius" } + } + } + + val setRings: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, + "set_rings".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rings" } + } + } + + val setSmoothFaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGSphere".cstr.ptr, + "set_smooth_faces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_smooth_faces" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CSGTorus.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CSGTorus.kt index d69ea2c1..0eb96a7f 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CSGTorus.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CSGTorus.kt @@ -202,77 +202,113 @@ open class CSGTorus( * Container for method_bind pointers for CSGTorus */ private object __method_bind { - val getInnerRadius: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, - "get_inner_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_inner_radius" } - } - val getMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, - "get_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_material" } - } - val getOuterRadius: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, - "get_outer_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_outer_radius" } - } - val getRingSides: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, - "get_ring_sides".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ring_sides" } - } - val getSides: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, - "get_sides".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sides" } - } - val getSmoothFaces: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, - "get_smooth_faces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_smooth_faces" } - } - val setInnerRadius: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, - "set_inner_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_inner_radius" } - } - val setMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, - "set_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_material" } - } - val setOuterRadius: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, - "set_outer_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_outer_radius" } - } - val setRingSides: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, - "set_ring_sides".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ring_sides" } - } - val setSides: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, - "set_sides".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sides" } - } - val setSmoothFaces: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, - "set_smooth_faces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_smooth_faces" } - }} + val getInnerRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, + "get_inner_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_inner_radius" } + } + } + + val getMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, + "get_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_material" } + } + } + + val getOuterRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, + "get_outer_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_outer_radius" } + } + } + + val getRingSides: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, + "get_ring_sides".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ring_sides" } + } + } + + val getSides: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, + "get_sides".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sides" } + } + } + + val getSmoothFaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, + "get_smooth_faces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_smooth_faces" } + } + } + + val setInnerRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, + "set_inner_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_inner_radius" } + } + } + + val setMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, + "set_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_material" } + } + } + + val setOuterRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, + "set_outer_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_outer_radius" } + } + } + + val setRingSides: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, + "set_ring_sides".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ring_sides" } + } + } + + val setSides: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, + "set_sides".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sides" } + } + } + + val setSmoothFaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CSGTorus".cstr.ptr, + "set_smooth_faces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_smooth_faces" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Camera.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Camera.kt index 42f35c15..faadc2a9 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Camera.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Camera.kt @@ -635,257 +635,341 @@ open class Camera( * Container for method_bind pointers for Camera */ private object __method_bind { - val clearCurrent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "clear_current".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_current" } - } - val getCameraRid: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "get_camera_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_camera_rid" } - } - val getCameraTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "get_camera_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_camera_transform" } - } - val getCullMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "get_cull_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cull_mask" } - } - val getCullMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "get_cull_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cull_mask_bit" } - } - val getDopplerTracking: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "get_doppler_tracking".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_doppler_tracking" } - } - val getEnvironment: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "get_environment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_environment" } - } - val getFov: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "get_fov".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fov" } - } - val getFrustum: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "get_frustum".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_frustum" } - } - val getFrustumOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "get_frustum_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_frustum_offset" } - } - val getHOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "get_h_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_h_offset" } - } - val getKeepAspectMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "get_keep_aspect_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_keep_aspect_mode" } - } - val getProjection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "get_projection".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_projection" } - } - val getSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "get_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_size" } - } - val getVOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "get_v_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_v_offset" } - } - val getZfar: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "get_zfar".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_zfar" } - } - val getZnear: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "get_znear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_znear" } - } - val isCurrent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "is_current".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_current" } - } - val isPositionBehind: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "is_position_behind".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_position_behind" } - } - val makeCurrent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "make_current".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method make_current" } - } - val projectLocalRayNormal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "project_local_ray_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method project_local_ray_normal" } - } - val projectPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "project_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method project_position" } - } - val projectRayNormal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "project_ray_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method project_ray_normal" } - } - val projectRayOrigin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "project_ray_origin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method project_ray_origin" } - } - val setCullMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "set_cull_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cull_mask" } - } - val setCullMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "set_cull_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cull_mask_bit" } - } - val setCurrent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "set_current".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_current" } - } - val setDopplerTracking: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "set_doppler_tracking".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_doppler_tracking" } - } - val setEnvironment: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "set_environment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_environment" } - } - val setFov: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "set_fov".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fov" } - } - val setFrustum: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "set_frustum".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_frustum" } - } - val setFrustumOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "set_frustum_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_frustum_offset" } - } - val setHOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "set_h_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_h_offset" } - } - val setKeepAspectMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "set_keep_aspect_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_keep_aspect_mode" } - } - val setOrthogonal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "set_orthogonal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_orthogonal" } - } - val setPerspective: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "set_perspective".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_perspective" } - } - val setProjection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "set_projection".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_projection" } - } - val setSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "set_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_size" } - } - val setVOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "set_v_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_v_offset" } - } - val setZfar: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "set_zfar".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_zfar" } - } - val setZnear: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "set_znear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_znear" } - } - val unprojectPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, - "unproject_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method unproject_position" } - }} + val clearCurrent: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "clear_current".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_current" } + } + } + + val getCameraRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "get_camera_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_camera_rid" } + } + } + + val getCameraTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "get_camera_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_camera_transform" } + } + } + + val getCullMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "get_cull_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cull_mask" } + } + } + + val getCullMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "get_cull_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cull_mask_bit" } + } + } + + val getDopplerTracking: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "get_doppler_tracking".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_doppler_tracking" } + } + } + + val getEnvironment: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "get_environment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_environment" } + } + } + + val getFov: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "get_fov".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fov" } + } + } + + val getFrustum: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "get_frustum".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_frustum" } + } + } + + val getFrustumOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "get_frustum_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_frustum_offset" } + } + } + + val getHOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "get_h_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_h_offset" } + } + } + + val getKeepAspectMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "get_keep_aspect_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_keep_aspect_mode" } + } + } + + val getProjection: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "get_projection".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_projection" } + } + } + + val getSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "get_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_size" } + } + } + + val getVOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "get_v_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_v_offset" } + } + } + + val getZfar: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "get_zfar".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_zfar" } + } + } + + val getZnear: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "get_znear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_znear" } + } + } + + val isCurrent: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "is_current".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_current" } + } + } + + val isPositionBehind: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "is_position_behind".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_position_behind" } + } + } + + val makeCurrent: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "make_current".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method make_current" } + } + } + + val projectLocalRayNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "project_local_ray_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method project_local_ray_normal" } + } + } + + val projectPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "project_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method project_position" } + } + } + + val projectRayNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "project_ray_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method project_ray_normal" } + } + } + + val projectRayOrigin: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "project_ray_origin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method project_ray_origin" } + } + } + + val setCullMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "set_cull_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cull_mask" } + } + } + + val setCullMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "set_cull_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cull_mask_bit" } + } + } + + val setCurrent: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "set_current".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_current" } + } + } + + val setDopplerTracking: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "set_doppler_tracking".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_doppler_tracking" } + } + } + + val setEnvironment: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "set_environment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_environment" } + } + } + + val setFov: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "set_fov".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fov" } + } + } + + val setFrustum: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "set_frustum".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_frustum" } + } + } + + val setFrustumOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "set_frustum_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_frustum_offset" } + } + } + + val setHOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "set_h_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_h_offset" } + } + } + + val setKeepAspectMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "set_keep_aspect_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_keep_aspect_mode" } + } + } + + val setOrthogonal: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "set_orthogonal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_orthogonal" } + } + } + + val setPerspective: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "set_perspective".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_perspective" } + } + } + + val setProjection: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "set_projection".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_projection" } + } + } + + val setSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "set_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_size" } + } + } + + val setVOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "set_v_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_v_offset" } + } + } + + val setZfar: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "set_zfar".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_zfar" } + } + } + + val setZnear: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "set_znear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_znear" } + } + } + + val unprojectPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera".cstr.ptr, + "unproject_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method unproject_position" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Camera2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Camera2D.kt index b74359ef..5c78d104 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Camera2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Camera2D.kt @@ -699,269 +699,401 @@ open class Camera2D( * Container for method_bind pointers for Camera2D */ private object __method_bind { - val align: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "align".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method align" } - } - val clearCurrent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "clear_current".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_current" } - } - val forceUpdateScroll: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "force_update_scroll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method force_update_scroll" } - } - val getAnchorMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "get_anchor_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_anchor_mode" } - } - val getCameraPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "get_camera_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_camera_position" } - } - val getCameraScreenCenter: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "get_camera_screen_center".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_camera_screen_center" } - } - val getCustomViewport: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "get_custom_viewport".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_custom_viewport" } - } - val getDragMargin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "get_drag_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_drag_margin" } - } - val getFollowSmoothing: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "get_follow_smoothing".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_follow_smoothing" } - } - val getHOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "get_h_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_h_offset" } - } - val getLimit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "get_limit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_limit" } - } - val getOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "get_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_offset" } - } - val getProcessMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "get_process_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_process_mode" } - } - val getVOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "get_v_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_v_offset" } - } - val getZoom: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "get_zoom".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_zoom" } - } - val isCurrent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "is_current".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_current" } - } - val isFollowSmoothingEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "is_follow_smoothing_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_follow_smoothing_enabled" } - } - val isHDragEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "is_h_drag_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_h_drag_enabled" } - } - val isLimitDrawingEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "is_limit_drawing_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_limit_drawing_enabled" } - } - val isLimitSmoothingEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "is_limit_smoothing_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_limit_smoothing_enabled" } - } - val isMarginDrawingEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "is_margin_drawing_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_margin_drawing_enabled" } - } - val isRotating: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "is_rotating".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_rotating" } - } - val isScreenDrawingEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "is_screen_drawing_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_screen_drawing_enabled" } - } - val isVDragEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "is_v_drag_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_v_drag_enabled" } - } - val makeCurrent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "make_current".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method make_current" } - } - val resetSmoothing: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "reset_smoothing".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method reset_smoothing" } - } - val setAnchorMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "set_anchor_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_anchor_mode" } - } - val setCustomViewport: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "set_custom_viewport".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_custom_viewport" } - } - val setDragMargin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "set_drag_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_drag_margin" } - } - val setEnableFollowSmoothing: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "set_enable_follow_smoothing".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_enable_follow_smoothing" } - } - val setFollowSmoothing: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "set_follow_smoothing".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_follow_smoothing" } - } - val setHDragEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "set_h_drag_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_h_drag_enabled" } - } - val setHOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "set_h_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_h_offset" } - } - val setLimit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "set_limit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_limit" } - } - val setLimitDrawingEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "set_limit_drawing_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_limit_drawing_enabled" } - } - val setLimitSmoothingEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "set_limit_smoothing_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_limit_smoothing_enabled" } - } - val setMarginDrawingEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "set_margin_drawing_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_margin_drawing_enabled" } - } - val setOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "set_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_offset" } - } - val setProcessMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "set_process_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_process_mode" } - } - val setRotating: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "set_rotating".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rotating" } - } - val setScreenDrawingEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "set_screen_drawing_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_screen_drawing_enabled" } - } - val setVDragEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "set_v_drag_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_v_drag_enabled" } - } - val setVOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "set_v_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_v_offset" } - } - val setZoom: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, - "set_zoom".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_zoom" } - }} + val align: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "align".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method align" } + } + } + + val clearCurrent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "clear_current".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_current" } + } + } + + val forceUpdateScroll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "force_update_scroll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method force_update_scroll" } + } + } + + val getAnchorMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "get_anchor_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_anchor_mode" } + } + } + + val getCameraPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "get_camera_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_camera_position" } + } + } + + val getCameraScreenCenter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "get_camera_screen_center".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_camera_screen_center" } + } + } + + val getCustomViewport: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "get_custom_viewport".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_custom_viewport" } + } + } + + val getDragMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "get_drag_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_drag_margin" } + } + } + + val getFollowSmoothing: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "get_follow_smoothing".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_follow_smoothing" } + } + } + + val getHOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "get_h_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_h_offset" } + } + } + + val getLimit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "get_limit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_limit" } + } + } + + val getOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "get_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_offset" } + } + } + + val getProcessMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "get_process_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_process_mode" } + } + } + + val getVOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "get_v_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_v_offset" } + } + } + + val getZoom: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "get_zoom".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_zoom" } + } + } + + val isCurrent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "is_current".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_current" } + } + } + + val isFollowSmoothingEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "is_follow_smoothing_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_follow_smoothing_enabled" } + } + } + + val isHDragEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "is_h_drag_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_h_drag_enabled" } + } + } + + val isLimitDrawingEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "is_limit_drawing_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_limit_drawing_enabled" } + } + } + + val isLimitSmoothingEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "is_limit_smoothing_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_limit_smoothing_enabled" } + } + } + + val isMarginDrawingEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "is_margin_drawing_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_margin_drawing_enabled" } + } + } + + val isRotating: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "is_rotating".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_rotating" } + } + } + + val isScreenDrawingEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "is_screen_drawing_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_screen_drawing_enabled" } + } + } + + val isVDragEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "is_v_drag_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_v_drag_enabled" } + } + } + + val makeCurrent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "make_current".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method make_current" } + } + } + + val resetSmoothing: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "reset_smoothing".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method reset_smoothing" } + } + } + + val setAnchorMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "set_anchor_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_anchor_mode" } + } + } + + val setCustomViewport: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "set_custom_viewport".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_custom_viewport" } + } + } + + val setDragMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "set_drag_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_drag_margin" } + } + } + + val setEnableFollowSmoothing: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "set_enable_follow_smoothing".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_enable_follow_smoothing" } + } + } + + val setFollowSmoothing: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "set_follow_smoothing".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_follow_smoothing" } + } + } + + val setHDragEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "set_h_drag_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_h_drag_enabled" } + } + } + + val setHOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "set_h_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_h_offset" } + } + } + + val setLimit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "set_limit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_limit" } + } + } + + val setLimitDrawingEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "set_limit_drawing_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_limit_drawing_enabled" } + } + } + + val setLimitSmoothingEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "set_limit_smoothing_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_limit_smoothing_enabled" } + } + } + + val setMarginDrawingEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "set_margin_drawing_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_margin_drawing_enabled" } + } + } + + val setOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "set_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_offset" } + } + } + + val setProcessMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "set_process_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_process_mode" } + } + } + + val setRotating: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "set_rotating".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rotating" } + } + } + + val setScreenDrawingEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "set_screen_drawing_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_screen_drawing_enabled" } + } + } + + val setVDragEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "set_v_drag_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_v_drag_enabled" } + } + } + + val setVOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "set_v_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_v_offset" } + } + } + + val setZoom: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Camera2D".cstr.ptr, + "set_zoom".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_zoom" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CameraFeed.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CameraFeed.kt index 6190041b..74194f06 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CameraFeed.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CameraFeed.kt @@ -216,47 +216,68 @@ open class CameraFeed( * Container for method_bind pointers for CameraFeed */ private object __method_bind { - val getId: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraFeed".cstr.ptr, - "get_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_id" } - } - val getName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraFeed".cstr.ptr, - "get_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_name" } - } - val getPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraFeed".cstr.ptr, - "get_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_position" } - } - val getTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraFeed".cstr.ptr, - "get_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_transform" } - } - val isActive: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraFeed".cstr.ptr, - "is_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_active" } - } - val setActive: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraFeed".cstr.ptr, - "set_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_active" } - } - val setTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraFeed".cstr.ptr, - "set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_transform" } - }} + val getId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraFeed".cstr.ptr, + "get_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_id" } + } + } + + val getName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraFeed".cstr.ptr, + "get_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_name" } + } + } + + val getPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraFeed".cstr.ptr, + "get_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_position" } + } + } + + val getTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraFeed".cstr.ptr, + "get_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_transform" } + } + } + + val isActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraFeed".cstr.ptr, + "is_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_active" } + } + } + + val setActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraFeed".cstr.ptr, + "set_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_active" } + } + } + + val setTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraFeed".cstr.ptr, + "set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_transform" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CameraServer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CameraServer.kt index f3da800b..d94d4ace 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CameraServer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CameraServer.kt @@ -93,41 +93,51 @@ open class CameraServerInternal( * Container for method_bind pointers for CameraServer */ private object __method_bind { - val addFeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraServer".cstr.ptr, - "add_feed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_feed" } - } - val feeds: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraServer".cstr.ptr, - "feeds".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method feeds" } - } - val getFeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraServer".cstr.ptr, - "get_feed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_feed" } - } - val getFeedCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraServer".cstr.ptr, - "get_feed_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_feed_count" } - } - val removeFeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraServer".cstr.ptr, - "remove_feed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_feed" } - }} + val addFeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraServer".cstr.ptr, + "add_feed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_feed" } + } + } + + val feeds: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraServer".cstr.ptr, + "feeds".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method feeds" } + } + } + + val getFeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraServer".cstr.ptr, + "get_feed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_feed" } + } + } + + val getFeedCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraServer".cstr.ptr, + "get_feed_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_feed_count" } + } + } + + val removeFeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraServer".cstr.ptr, + "remove_feed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_feed" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CameraTexture.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CameraTexture.kt index a54fd9d6..e5ca7951 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CameraTexture.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CameraTexture.kt @@ -124,47 +124,59 @@ open class CameraTexture( * Container for method_bind pointers for CameraTexture */ private object __method_bind { - val getCameraActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraTexture".cstr.ptr, - "get_camera_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_camera_active" } - } - val getCameraFeedId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraTexture".cstr.ptr, - "get_camera_feed_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_camera_feed_id" } - } - val getWhichFeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraTexture".cstr.ptr, - "get_which_feed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_which_feed" } - } - val setCameraActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraTexture".cstr.ptr, - "set_camera_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_camera_active" } - } - val setCameraFeedId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraTexture".cstr.ptr, - "set_camera_feed_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_camera_feed_id" } - } - val setWhichFeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraTexture".cstr.ptr, - "set_which_feed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_which_feed" } - }} + val getCameraActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraTexture".cstr.ptr, + "get_camera_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_camera_active" } + } + } + + val getCameraFeedId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraTexture".cstr.ptr, + "get_camera_feed_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_camera_feed_id" } + } + } + + val getWhichFeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraTexture".cstr.ptr, + "get_which_feed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_which_feed" } + } + } + + val setCameraActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraTexture".cstr.ptr, + "set_camera_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_camera_active" } + } + } + + val setCameraFeedId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraTexture".cstr.ptr, + "set_camera_feed_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_camera_feed_id" } + } + } + + val setWhichFeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CameraTexture".cstr.ptr, + "set_which_feed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_which_feed" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CanvasItem.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CanvasItem.kt index b6966d00..0d1dc639 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CanvasItem.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CanvasItem.kt @@ -1002,361 +1002,540 @@ open class CanvasItem( * Container for method_bind pointers for CanvasItem */ private object __method_bind { - val drawArc: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_arc".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_arc" } - } - val drawChar: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_char".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_char" } - } - val drawCircle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_circle".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_circle" } - } - val drawColoredPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_colored_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_colored_polygon" } - } - val drawLine: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_line" } - } - val drawMesh: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_mesh" } - } - val drawMultiline: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_multiline".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_multiline" } - } - val drawMultilineColors: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_multiline_colors".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_multiline_colors" } - } - val drawMultimesh: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_multimesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_multimesh" } - } - val drawPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_polygon" } - } - val drawPolyline: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_polyline".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_polyline" } - } - val drawPolylineColors: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_polyline_colors".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_polyline_colors" } - } - val drawPrimitive: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_primitive".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_primitive" } - } - val drawRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_rect" } - } - val drawSetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_set_transform" } - } - val drawSetTransformMatrix: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_set_transform_matrix".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_set_transform_matrix" } - } - val drawString: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_string".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_string" } - } - val drawStyleBox: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_style_box".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_style_box" } - } - val drawTexture: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_texture" } - } - val drawTextureRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_texture_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_texture_rect" } - } - val drawTextureRectRegion: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "draw_texture_rect_region".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_texture_rect_region" } - } - val forceUpdateTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "force_update_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method force_update_transform" } - } - val getCanvas: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "get_canvas".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_canvas" } - } - val getCanvasItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "get_canvas_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_canvas_item" } - } - val getCanvasTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "get_canvas_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_canvas_transform" } - } - val getGlobalMousePosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "get_global_mouse_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_global_mouse_position" } - } - val getGlobalTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "get_global_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_global_transform" } - } - val getGlobalTransformWithCanvas: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "get_global_transform_with_canvas".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_global_transform_with_canvas" } - } - val getLightMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "get_light_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_light_mask" } - } - val getLocalMousePosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "get_local_mouse_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_local_mouse_position" } - } - val getMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "get_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_material" } - } - val getModulate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "get_modulate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_modulate" } - } - val getSelfModulate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "get_self_modulate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_self_modulate" } - } - val getTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "get_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_transform" } - } - val getUseParentMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "get_use_parent_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_use_parent_material" } - } - val getViewportRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "get_viewport_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_viewport_rect" } - } - val getViewportTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "get_viewport_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_viewport_transform" } - } - val getWorld2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "get_world_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_world_2d" } - } - val hide: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "hide".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method hide" } - } - val isDrawBehindParentEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "is_draw_behind_parent_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_draw_behind_parent_enabled" } - } - val isLocalTransformNotificationEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "is_local_transform_notification_enabled".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method is_local_transform_notification_enabled" } - } - val isSetAsToplevel: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "is_set_as_toplevel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_set_as_toplevel" } - } - val isTransformNotificationEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "is_transform_notification_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_transform_notification_enabled" + val drawArc: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_arc".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_arc" } } - } - val isVisible: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "is_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_visible" } - } - val isVisibleInTree: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "is_visible_in_tree".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_visible_in_tree" } - } - val makeCanvasPositionLocal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "make_canvas_position_local".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method make_canvas_position_local" } - } - val makeInputLocal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "make_input_local".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method make_input_local" } - } - val setAsToplevel: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "set_as_toplevel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_as_toplevel" } - } - val setDrawBehindParent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "set_draw_behind_parent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_draw_behind_parent" } - } - val setLightMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "set_light_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_light_mask" } - } - val setMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "set_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_material" } - } - val setModulate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "set_modulate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_modulate" } - } - val setNotifyLocalTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "set_notify_local_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_notify_local_transform" } - } - val setNotifyTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "set_notify_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_notify_transform" } - } - val setSelfModulate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "set_self_modulate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_self_modulate" } - } - val setUseParentMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "set_use_parent_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_parent_material" } - } - val setVisible: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "set_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_visible" } - } - val show: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "show".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method show" } - } - val update: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, - "update".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method update" } - }} + } + + val drawChar: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_char".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_char" } + } + } + + val drawCircle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_circle".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_circle" } + } + } + + val drawColoredPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_colored_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_colored_polygon" } + } + } + + val drawLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_line" } + } + } + + val drawMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_mesh" } + } + } + + val drawMultiline: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_multiline".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_multiline" } + } + } + + val drawMultilineColors: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_multiline_colors".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_multiline_colors" } + } + } + + val drawMultimesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_multimesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_multimesh" } + } + } + + val drawPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_polygon" } + } + } + + val drawPolyline: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_polyline".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_polyline" } + } + } + + val drawPolylineColors: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_polyline_colors".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_polyline_colors" } + } + } + + val drawPrimitive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_primitive".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_primitive" } + } + } + + val drawRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_rect" } + } + } + + val drawSetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_set_transform" } + } + } + + val drawSetTransformMatrix: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_set_transform_matrix".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_set_transform_matrix" } + } + } + + val drawString: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_string".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_string" } + } + } + + val drawStyleBox: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_style_box".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_style_box" } + } + } + + val drawTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_texture" } + } + } + + val drawTextureRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_texture_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_texture_rect" } + } + } + + val drawTextureRectRegion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "draw_texture_rect_region".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_texture_rect_region" } + } + } + + val forceUpdateTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "force_update_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method force_update_transform" } + } + } + + val getCanvas: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "get_canvas".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_canvas" } + } + } + + val getCanvasItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "get_canvas_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_canvas_item" } + } + } + + val getCanvasTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "get_canvas_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_canvas_transform" } + } + } + + val getGlobalMousePosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "get_global_mouse_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_global_mouse_position" } + } + } + + val getGlobalTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "get_global_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_global_transform" } + } + } + + val getGlobalTransformWithCanvas: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "get_global_transform_with_canvas".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_global_transform_with_canvas" } + } + } + + val getLightMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "get_light_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_light_mask" } + } + } + + val getLocalMousePosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "get_local_mouse_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_local_mouse_position" } + } + } + + val getMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "get_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_material" } + } + } + + val getModulate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "get_modulate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_modulate" } + } + } + + val getSelfModulate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "get_self_modulate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_self_modulate" } + } + } + + val getTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "get_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_transform" } + } + } + + val getUseParentMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "get_use_parent_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_use_parent_material" } + } + } + + val getViewportRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "get_viewport_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_viewport_rect" } + } + } + + val getViewportTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "get_viewport_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_viewport_transform" } + } + } + + val getWorld2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "get_world_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_world_2d" } + } + } + + val hide: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "hide".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method hide" } + } + } + + val isDrawBehindParentEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "is_draw_behind_parent_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_draw_behind_parent_enabled" + } + } + } + + val isLocalTransformNotificationEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "is_local_transform_notification_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_local_transform_notification_enabled" } + } + } + + val isSetAsToplevel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "is_set_as_toplevel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_set_as_toplevel" } + } + } + + val isTransformNotificationEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "is_transform_notification_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_transform_notification_enabled" } + } + } + + val isVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "is_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_visible" } + } + } + + val isVisibleInTree: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "is_visible_in_tree".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_visible_in_tree" } + } + } + + val makeCanvasPositionLocal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "make_canvas_position_local".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method make_canvas_position_local" } + } + } + + val makeInputLocal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "make_input_local".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method make_input_local" } + } + } + + val setAsToplevel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "set_as_toplevel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_as_toplevel" } + } + } + + val setDrawBehindParent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "set_draw_behind_parent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_draw_behind_parent" } + } + } + + val setLightMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "set_light_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_light_mask" } + } + } + + val setMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "set_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_material" } + } + } + + val setModulate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "set_modulate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_modulate" } + } + } + + val setNotifyLocalTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "set_notify_local_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_notify_local_transform" } + } + } + + val setNotifyTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "set_notify_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_notify_transform" } + } + } + + val setSelfModulate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "set_self_modulate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_self_modulate" } + } + } + + val setUseParentMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "set_use_parent_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_parent_material" } + } + } + + val setVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "set_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_visible" } + } + } + + val show: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "show".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method show" } + } + } + + val update: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItem".cstr.ptr, + "update".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method update" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CanvasItemMaterial.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CanvasItemMaterial.kt index 6915f3ee..aeae0007 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CanvasItemMaterial.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CanvasItemMaterial.kt @@ -246,89 +246,113 @@ open class CanvasItemMaterial( * Container for method_bind pointers for CanvasItemMaterial */ private object __method_bind { - val getBlendMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, - "get_blend_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_blend_mode" } - } - val getLightMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, - "get_light_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_light_mode" } - } - val getParticlesAnimHFrames: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, - "get_particles_anim_h_frames".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_particles_anim_h_frames" } - } - val getParticlesAnimLoop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, - "get_particles_anim_loop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_particles_anim_loop" } - } - val getParticlesAnimVFrames: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, - "get_particles_anim_v_frames".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_particles_anim_v_frames" } - } - val getParticlesAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, - "get_particles_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_particles_animation" } - } - val setBlendMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, - "set_blend_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_blend_mode" } - } - val setLightMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, - "set_light_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_light_mode" } - } - val setParticlesAnimHFrames: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, - "set_particles_anim_h_frames".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_particles_anim_h_frames" } - } - val setParticlesAnimLoop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, - "set_particles_anim_loop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_particles_anim_loop" } - } - val setParticlesAnimVFrames: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, - "set_particles_anim_v_frames".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_particles_anim_v_frames" } - } - val setParticlesAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, - "set_particles_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_particles_animation" } - }} + val getBlendMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, + "get_blend_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_blend_mode" } + } + } + + val getLightMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, + "get_light_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_light_mode" } + } + } + + val getParticlesAnimHFrames: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, + "get_particles_anim_h_frames".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_particles_anim_h_frames" } + } + } + + val getParticlesAnimLoop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, + "get_particles_anim_loop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_particles_anim_loop" } + } + } + + val getParticlesAnimVFrames: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, + "get_particles_anim_v_frames".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_particles_anim_v_frames" } + } + } + + val getParticlesAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, + "get_particles_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_particles_animation" } + } + } + + val setBlendMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, + "set_blend_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_blend_mode" } + } + } + + val setLightMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, + "set_light_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_light_mode" } + } + } + + val setParticlesAnimHFrames: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, + "set_particles_anim_h_frames".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_particles_anim_h_frames" } + } + } + + val setParticlesAnimLoop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, + "set_particles_anim_loop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_particles_anim_loop" } + } + } + + val setParticlesAnimVFrames: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, + "set_particles_anim_v_frames".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_particles_anim_v_frames" } + } + } + + val setParticlesAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasItemMaterial".cstr.ptr, + "set_particles_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_particles_animation" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CanvasLayer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CanvasLayer.kt index ef9b97f2..a265683d 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CanvasLayer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CanvasLayer.kt @@ -322,138 +322,176 @@ open class CanvasLayer( * Container for method_bind pointers for CanvasLayer */ private object __method_bind { - val getCanvas: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, - "get_canvas".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_canvas" } - } - val getCustomViewport: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, - "get_custom_viewport".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_custom_viewport" } - } - val getFollowViewportScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, - "get_follow_viewport_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_follow_viewport_scale" } - } - val getLayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, - "get_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_layer" } - } - val getOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, - "get_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_offset" } - } - val getRotation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, - "get_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rotation" } - } - val getRotationDegrees: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, - "get_rotation_degrees".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rotation_degrees" } - } - val getScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, - "get_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_scale" } - } - val getTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, - "get_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_transform" } - } - val isFollowingViewport: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, - "is_following_viewport".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_following_viewport" } - } - val setCustomViewport: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, - "set_custom_viewport".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_custom_viewport" } - } - val setFollowViewport: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, - "set_follow_viewport".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_follow_viewport" } - } - val setFollowViewportScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, - "set_follow_viewport_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_follow_viewport_scale" } - } - val setLayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, - "set_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_layer" } - } - val setOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, - "set_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_offset" } - } - val setRotation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, - "set_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rotation" } - } - val setRotationDegrees: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, - "set_rotation_degrees".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rotation_degrees" } - } - val setScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, - "set_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_scale" } - } - val setTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, - "set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_transform" } - }} + val getCanvas: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, + "get_canvas".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_canvas" } + } + } + + val getCustomViewport: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, + "get_custom_viewport".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_custom_viewport" } + } + } + + val getFollowViewportScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, + "get_follow_viewport_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_follow_viewport_scale" } + } + } + + val getLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, + "get_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_layer" } + } + } + + val getOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, + "get_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_offset" } + } + } + + val getRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, + "get_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rotation" } + } + } + + val getRotationDegrees: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, + "get_rotation_degrees".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rotation_degrees" } + } + } + + val getScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, + "get_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_scale" } + } + } + + val getTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, + "get_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_transform" } + } + } + + val isFollowingViewport: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, + "is_following_viewport".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_following_viewport" } + } + } + + val setCustomViewport: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, + "set_custom_viewport".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_custom_viewport" } + } + } + + val setFollowViewport: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, + "set_follow_viewport".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_follow_viewport" } + } + } + + val setFollowViewportScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, + "set_follow_viewport_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_follow_viewport_scale" } + } + } + + val setLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, + "set_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_layer" } + } + } + + val setOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, + "set_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_offset" } + } + } + + val setRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, + "set_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rotation" } + } + } + + val setRotationDegrees: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, + "set_rotation_degrees".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rotation_degrees" } + } + } + + val setScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, + "set_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_scale" } + } + } + + val setTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasLayer".cstr.ptr, + "set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_transform" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CanvasModulate.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CanvasModulate.kt index 370a4f6e..1669e7be 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CanvasModulate.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CanvasModulate.kt @@ -85,19 +85,23 @@ open class CanvasModulate( * Container for method_bind pointers for CanvasModulate */ private object __method_bind { - val getColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasModulate".cstr.ptr, - "get_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_color" } - } - val setColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasModulate".cstr.ptr, - "set_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_color" } - }} + val getColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasModulate".cstr.ptr, + "get_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_color" } + } + } + + val setColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CanvasModulate".cstr.ptr, + "set_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_color" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CapsuleMesh.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CapsuleMesh.kt index 719f9042..f7b98c57 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CapsuleMesh.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CapsuleMesh.kt @@ -149,61 +149,77 @@ open class CapsuleMesh( * Container for method_bind pointers for CapsuleMesh */ private object __method_bind { - val getMidHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleMesh".cstr.ptr, - "get_mid_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mid_height" } - } - val getRadialSegments: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleMesh".cstr.ptr, - "get_radial_segments".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_radial_segments" } - } - val getRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleMesh".cstr.ptr, - "get_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_radius" } - } - val getRings: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleMesh".cstr.ptr, - "get_rings".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rings" } - } - val setMidHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleMesh".cstr.ptr, - "set_mid_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mid_height" } - } - val setRadialSegments: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleMesh".cstr.ptr, - "set_radial_segments".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_radial_segments" } - } - val setRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleMesh".cstr.ptr, - "set_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_radius" } - } - val setRings: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleMesh".cstr.ptr, - "set_rings".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rings" } - }} + val getMidHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleMesh".cstr.ptr, + "get_mid_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mid_height" } + } + } + + val getRadialSegments: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleMesh".cstr.ptr, + "get_radial_segments".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_radial_segments" } + } + } + + val getRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleMesh".cstr.ptr, + "get_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_radius" } + } + } + + val getRings: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleMesh".cstr.ptr, + "get_rings".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rings" } + } + } + + val setMidHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleMesh".cstr.ptr, + "set_mid_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mid_height" } + } + } + + val setRadialSegments: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleMesh".cstr.ptr, + "set_radial_segments".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_radial_segments" } + } + } + + val setRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleMesh".cstr.ptr, + "set_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_radius" } + } + } + + val setRings: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleMesh".cstr.ptr, + "set_rings".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rings" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CapsuleShape.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CapsuleShape.kt index 94229c01..4b9e1ca0 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CapsuleShape.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CapsuleShape.kt @@ -98,33 +98,41 @@ open class CapsuleShape( * Container for method_bind pointers for CapsuleShape */ private object __method_bind { - val getHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleShape".cstr.ptr, - "get_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_height" } - } - val getRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleShape".cstr.ptr, - "get_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_radius" } - } - val setHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleShape".cstr.ptr, - "set_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_height" } - } - val setRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleShape".cstr.ptr, - "set_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_radius" } - }} + val getHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleShape".cstr.ptr, + "get_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_height" } + } + } + + val getRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleShape".cstr.ptr, + "get_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_radius" } + } + } + + val setHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleShape".cstr.ptr, + "set_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_height" } + } + } + + val setRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleShape".cstr.ptr, + "set_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_radius" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CapsuleShape2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CapsuleShape2D.kt index 8e884251..5ec872b2 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CapsuleShape2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CapsuleShape2D.kt @@ -99,33 +99,41 @@ open class CapsuleShape2D( * Container for method_bind pointers for CapsuleShape2D */ private object __method_bind { - val getHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleShape2D".cstr.ptr, - "get_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_height" } - } - val getRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleShape2D".cstr.ptr, - "get_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_radius" } - } - val setHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleShape2D".cstr.ptr, - "set_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_height" } - } - val setRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleShape2D".cstr.ptr, - "set_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_radius" } - }} + val getHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleShape2D".cstr.ptr, + "get_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_height" } + } + } + + val getRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleShape2D".cstr.ptr, + "get_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_radius" } + } + } + + val setHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleShape2D".cstr.ptr, + "set_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_height" } + } + } + + val setRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CapsuleShape2D".cstr.ptr, + "set_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_radius" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CenterContainer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CenterContainer.kt index d97c75a3..4835a95c 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CenterContainer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CenterContainer.kt @@ -74,19 +74,23 @@ open class CenterContainer( * Container for method_bind pointers for CenterContainer */ private object __method_bind { - val isUsingTopLeft: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CenterContainer".cstr.ptr, - "is_using_top_left".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_using_top_left" } - } - val setUseTopLeft: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CenterContainer".cstr.ptr, - "set_use_top_left".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_top_left" } - }} + val isUsingTopLeft: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CenterContainer".cstr.ptr, + "is_using_top_left".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_using_top_left" } + } + } + + val setUseTopLeft: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CenterContainer".cstr.ptr, + "set_use_top_left".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_top_left" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CharFXTransform.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CharFXTransform.kt index 13022147..a3416f1a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CharFXTransform.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CharFXTransform.kt @@ -285,117 +285,149 @@ open class CharFXTransform( * Container for method_bind pointers for CharFXTransform */ private object __method_bind { - val getAbsoluteIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, - "get_absolute_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_absolute_index" } - } - val getCharacter: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, - "get_character".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_character" } - } - val getColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, - "get_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_color" } - } - val getElapsedTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, - "get_elapsed_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_elapsed_time" } - } - val getEnvironment: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, - "get_environment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_environment" } - } - val getOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, - "get_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_offset" } - } - val getRelativeIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, - "get_relative_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_relative_index" } - } - val isVisible: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, - "is_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_visible" } - } - val setAbsoluteIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, - "set_absolute_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_absolute_index" } - } - val setCharacter: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, - "set_character".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_character" } - } - val setColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, - "set_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_color" } - } - val setElapsedTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, - "set_elapsed_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_elapsed_time" } - } - val setEnvironment: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, - "set_environment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_environment" } - } - val setOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, - "set_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_offset" } - } - val setRelativeIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, - "set_relative_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_relative_index" } - } - val setVisibility: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, - "set_visibility".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_visibility" } - }} + val getAbsoluteIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, + "get_absolute_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_absolute_index" } + } + } + + val getCharacter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, + "get_character".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_character" } + } + } + + val getColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, + "get_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_color" } + } + } + + val getElapsedTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, + "get_elapsed_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_elapsed_time" } + } + } + + val getEnvironment: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, + "get_environment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_environment" } + } + } + + val getOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, + "get_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_offset" } + } + } + + val getRelativeIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, + "get_relative_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_relative_index" } + } + } + + val isVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, + "is_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_visible" } + } + } + + val setAbsoluteIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, + "set_absolute_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_absolute_index" } + } + } + + val setCharacter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, + "set_character".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_character" } + } + } + + val setColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, + "set_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_color" } + } + } + + val setElapsedTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, + "set_elapsed_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_elapsed_time" } + } + } + + val setEnvironment: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, + "set_environment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_environment" } + } + } + + val setOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, + "set_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_offset" } + } + } + + val setRelativeIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, + "set_relative_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_relative_index" } + } + } + + val setVisibility: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CharFXTransform".cstr.ptr, + "set_visibility".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_visibility" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CircleShape2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CircleShape2D.kt index 0c5e4d28..0b02f95c 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CircleShape2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CircleShape2D.kt @@ -73,19 +73,23 @@ open class CircleShape2D( * Container for method_bind pointers for CircleShape2D */ private object __method_bind { - val getRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CircleShape2D".cstr.ptr, - "get_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_radius" } - } - val setRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CircleShape2D".cstr.ptr, - "set_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_radius" } - }} + val getRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CircleShape2D".cstr.ptr, + "get_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_radius" } + } + } + + val setRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CircleShape2D".cstr.ptr, + "set_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_radius" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ClassDB.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ClassDB.kt index c71ad761..647a3502 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ClassDB.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ClassDB.kt @@ -298,126 +298,187 @@ open class ClassDBInternal( * Container for method_bind pointers for ClassDB */ private object __method_bind { - val canInstance: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "can_instance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method can_instance" } - } - val classExists: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "class_exists".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method class_exists" } - } - val classGetCategory: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "class_get_category".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method class_get_category" } - } - val classGetIntegerConstant: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "class_get_integer_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method class_get_integer_constant" } - } - val classGetIntegerConstantList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "class_get_integer_constant_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method class_get_integer_constant_list" } - } - val classGetMethodList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "class_get_method_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method class_get_method_list" } - } - val classGetProperty: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "class_get_property".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method class_get_property" } - } - val classGetPropertyList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "class_get_property_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method class_get_property_list" } - } - val classGetSignal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "class_get_signal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method class_get_signal" } - } - val classGetSignalList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "class_get_signal_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method class_get_signal_list" } - } - val classHasIntegerConstant: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "class_has_integer_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method class_has_integer_constant" } - } - val classHasMethod: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "class_has_method".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method class_has_method" } - } - val classHasSignal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "class_has_signal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method class_has_signal" } - } - val classSetProperty: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "class_set_property".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method class_set_property" } - } - val getClassList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "get_class_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_class_list" } - } - val getInheritersFromClass: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "get_inheriters_from_class".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_inheriters_from_class" } - } - val getParentClass: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "get_parent_class".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_parent_class" } - } - val instance: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "instance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instance" } - } - val isClassEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "is_class_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_class_enabled" } - } - val isParentClass: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, - "is_parent_class".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_parent_class" } - }} + val canInstance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "can_instance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method can_instance" } + } + } + + val classExists: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "class_exists".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method class_exists" } + } + } + + val classGetCategory: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "class_get_category".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method class_get_category" } + } + } + + val classGetIntegerConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "class_get_integer_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method class_get_integer_constant" } + } + } + + val classGetIntegerConstantList: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "class_get_integer_constant_list".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method class_get_integer_constant_list" } + } + } + + val classGetMethodList: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "class_get_method_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method class_get_method_list" } + } + } + + val classGetProperty: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "class_get_property".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method class_get_property" } + } + } + + val classGetPropertyList: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "class_get_property_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method class_get_property_list" } + } + } + + val classGetSignal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "class_get_signal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method class_get_signal" } + } + } + + val classGetSignalList: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "class_get_signal_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method class_get_signal_list" } + } + } + + val classHasIntegerConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "class_has_integer_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method class_has_integer_constant" } + } + } + + val classHasMethod: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "class_has_method".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method class_has_method" } + } + } + + val classHasSignal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "class_has_signal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method class_has_signal" } + } + } + + val classSetProperty: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "class_set_property".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method class_set_property" } + } + } + + val getClassList: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "get_class_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_class_list" } + } + } + + val getInheritersFromClass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "get_inheriters_from_class".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_inheriters_from_class" } + } + } + + val getParentClass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "get_parent_class".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_parent_class" } + } + } + + val instance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "instance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method instance" } + } + } + + val isClassEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "is_class_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_class_enabled" } + } + } + + val isParentClass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ClassDB".cstr.ptr, + "is_parent_class".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_parent_class" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ClippedCamera.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ClippedCamera.kt index 858918b4..52d0295d 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ClippedCamera.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ClippedCamera.kt @@ -260,131 +260,167 @@ open class ClippedCamera( * Container for method_bind pointers for ClippedCamera */ private object __method_bind { - val addException: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, - "add_exception".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_exception" } - } - val addExceptionRid: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, - "add_exception_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_exception_rid" } - } - val clearExceptions: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, - "clear_exceptions".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_exceptions" } - } - val getClipOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, - "get_clip_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_clip_offset" } - } - val getCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, - "get_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } - } - val getCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, - "get_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } - } - val getMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, - "get_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_margin" } - } - val getProcessMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, - "get_process_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_process_mode" } - } - val isClipToAreasEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, - "is_clip_to_areas_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_clip_to_areas_enabled" } - } - val isClipToBodiesEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, - "is_clip_to_bodies_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_clip_to_bodies_enabled" } - } - val removeException: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, - "remove_exception".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_exception" } - } - val removeExceptionRid: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, - "remove_exception_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_exception_rid" } - } - val setClipToAreas: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, - "set_clip_to_areas".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_clip_to_areas" } - } - val setClipToBodies: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, - "set_clip_to_bodies".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_clip_to_bodies" } - } - val setCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, - "set_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } - } - val setCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, - "set_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } - } - val setMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, - "set_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_margin" } - } - val setProcessMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, - "set_process_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_process_mode" } - }} + val addException: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, + "add_exception".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_exception" } + } + } + + val addExceptionRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, + "add_exception_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_exception_rid" } + } + } + + val clearExceptions: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, + "clear_exceptions".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_exceptions" } + } + } + + val getClipOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, + "get_clip_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_clip_offset" } + } + } + + val getCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, + "get_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } + } + } + + val getCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, + "get_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } + } + } + + val getMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, + "get_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_margin" } + } + } + + val getProcessMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, + "get_process_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_process_mode" } + } + } + + val isClipToAreasEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, + "is_clip_to_areas_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_clip_to_areas_enabled" } + } + } + + val isClipToBodiesEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, + "is_clip_to_bodies_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_clip_to_bodies_enabled" } + } + } + + val removeException: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, + "remove_exception".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_exception" } + } + } + + val removeExceptionRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, + "remove_exception_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_exception_rid" } + } + } + + val setClipToAreas: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, + "set_clip_to_areas".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_clip_to_areas" } + } + } + + val setClipToBodies: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, + "set_clip_to_bodies".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_clip_to_bodies" } + } + } + + val setCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, + "set_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } + } + } + + val setCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, + "set_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } + } + } + + val setMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, + "set_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_margin" } + } + } + + val setProcessMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ClippedCamera".cstr.ptr, + "set_process_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_process_mode" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CollisionObject.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CollisionObject.kt index 29d1d710..7957013c 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CollisionObject.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CollisionObject.kt @@ -288,145 +288,185 @@ open class CollisionObject( * Container for method_bind pointers for CollisionObject */ private object __method_bind { - val createShapeOwner: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "create_shape_owner".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_shape_owner" } - } - val getCaptureInputOnDrag: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "get_capture_input_on_drag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_capture_input_on_drag" } - } - val getRid: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "get_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rid" } - } - val getShapeOwners: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "get_shape_owners".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shape_owners" } - } - val isRayPickable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "is_ray_pickable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_ray_pickable" } - } - val isShapeOwnerDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "is_shape_owner_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_shape_owner_disabled" } - } - val removeShapeOwner: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "remove_shape_owner".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_shape_owner" } - } - val setCaptureInputOnDrag: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "set_capture_input_on_drag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_capture_input_on_drag" } - } - val setRayPickable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "set_ray_pickable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ray_pickable" } - } - val shapeFindOwner: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "shape_find_owner".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_find_owner" } - } - val shapeOwnerAddShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "shape_owner_add_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_add_shape" } - } - val shapeOwnerClearShapes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "shape_owner_clear_shapes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_clear_shapes" } - } - val shapeOwnerGetOwner: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "shape_owner_get_owner".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_get_owner" } - } - val shapeOwnerGetShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "shape_owner_get_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_get_shape" } - } - val shapeOwnerGetShapeCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "shape_owner_get_shape_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_get_shape_count" } - } - val shapeOwnerGetShapeIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "shape_owner_get_shape_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_get_shape_index" } - } - val shapeOwnerGetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "shape_owner_get_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_get_transform" } - } - val shapeOwnerRemoveShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "shape_owner_remove_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_remove_shape" } - } - val shapeOwnerSetDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "shape_owner_set_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_set_disabled" } - } - val shapeOwnerSetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, - "shape_owner_set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_set_transform" } - }} + val createShapeOwner: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "create_shape_owner".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_shape_owner" } + } + } + + val getCaptureInputOnDrag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "get_capture_input_on_drag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_capture_input_on_drag" } + } + } + + val getRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "get_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rid" } + } + } + + val getShapeOwners: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "get_shape_owners".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shape_owners" } + } + } + + val isRayPickable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "is_ray_pickable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_ray_pickable" } + } + } + + val isShapeOwnerDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "is_shape_owner_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_shape_owner_disabled" } + } + } + + val removeShapeOwner: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "remove_shape_owner".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_shape_owner" } + } + } + + val setCaptureInputOnDrag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "set_capture_input_on_drag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_capture_input_on_drag" } + } + } + + val setRayPickable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "set_ray_pickable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ray_pickable" } + } + } + + val shapeFindOwner: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "shape_find_owner".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_find_owner" } + } + } + + val shapeOwnerAddShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "shape_owner_add_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_add_shape" } + } + } + + val shapeOwnerClearShapes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "shape_owner_clear_shapes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_clear_shapes" } + } + } + + val shapeOwnerGetOwner: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "shape_owner_get_owner".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_get_owner" } + } + } + + val shapeOwnerGetShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "shape_owner_get_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_get_shape" } + } + } + + val shapeOwnerGetShapeCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "shape_owner_get_shape_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_get_shape_count" } + } + } + + val shapeOwnerGetShapeIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "shape_owner_get_shape_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_get_shape_index" } + } + } + + val shapeOwnerGetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "shape_owner_get_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_get_transform" } + } + } + + val shapeOwnerRemoveShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "shape_owner_remove_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_remove_shape" } + } + } + + val shapeOwnerSetDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "shape_owner_set_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_set_disabled" } + } + } + + val shapeOwnerSetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject".cstr.ptr, + "shape_owner_set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_set_transform" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CollisionObject2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CollisionObject2D.kt index 0eaa2891..a204a7c5 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CollisionObject2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CollisionObject2D.kt @@ -301,163 +301,207 @@ open class CollisionObject2D( * Container for method_bind pointers for CollisionObject2D */ private object __method_bind { - val createShapeOwner: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "create_shape_owner".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_shape_owner" } - } - val getRid: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "get_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rid" } - } - val getShapeOwnerOneWayCollisionMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "get_shape_owner_one_way_collision_margin".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method get_shape_owner_one_way_collision_margin" } - } - val getShapeOwners: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "get_shape_owners".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shape_owners" } - } - val isPickable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "is_pickable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_pickable" } - } - val isShapeOwnerDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "is_shape_owner_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_shape_owner_disabled" } - } - val isShapeOwnerOneWayCollisionEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "is_shape_owner_one_way_collision_enabled".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method is_shape_owner_one_way_collision_enabled" } - } - val removeShapeOwner: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "remove_shape_owner".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_shape_owner" } - } - val setPickable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "set_pickable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pickable" } - } - val shapeFindOwner: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "shape_find_owner".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_find_owner" } - } - val shapeOwnerAddShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "shape_owner_add_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_add_shape" } - } - val shapeOwnerClearShapes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "shape_owner_clear_shapes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_clear_shapes" } - } - val shapeOwnerGetOwner: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "shape_owner_get_owner".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_get_owner" } - } - val shapeOwnerGetShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "shape_owner_get_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_get_shape" } - } - val shapeOwnerGetShapeCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "shape_owner_get_shape_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_get_shape_count" } - } - val shapeOwnerGetShapeIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "shape_owner_get_shape_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_get_shape_index" } - } - val shapeOwnerGetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "shape_owner_get_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_get_transform" } - } - val shapeOwnerRemoveShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "shape_owner_remove_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_remove_shape" } - } - val shapeOwnerSetDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "shape_owner_set_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_set_disabled" } - } - val shapeOwnerSetOneWayCollision: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "shape_owner_set_one_way_collision".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_set_one_way_collision" + val createShapeOwner: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "create_shape_owner".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_shape_owner" } } - } - val shapeOwnerSetOneWayCollisionMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "shape_owner_set_one_way_collision_margin".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method shape_owner_set_one_way_collision_margin" } - } - val shapeOwnerSetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, - "shape_owner_set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_owner_set_transform" } - }} + } + + val getRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "get_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rid" } + } + } + + val getShapeOwnerOneWayCollisionMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "get_shape_owner_one_way_collision_margin".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_shape_owner_one_way_collision_margin" } + } + } + + val getShapeOwners: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "get_shape_owners".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shape_owners" } + } + } + + val isPickable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "is_pickable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_pickable" } + } + } + + val isShapeOwnerDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "is_shape_owner_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_shape_owner_disabled" } + } + } + + val isShapeOwnerOneWayCollisionEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "is_shape_owner_one_way_collision_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_shape_owner_one_way_collision_enabled" } + } + } + + val removeShapeOwner: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "remove_shape_owner".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_shape_owner" } + } + } + + val setPickable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "set_pickable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pickable" } + } + } + + val shapeFindOwner: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "shape_find_owner".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_find_owner" } + } + } + + val shapeOwnerAddShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "shape_owner_add_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_add_shape" } + } + } + + val shapeOwnerClearShapes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "shape_owner_clear_shapes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_clear_shapes" } + } + } + + val shapeOwnerGetOwner: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "shape_owner_get_owner".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_get_owner" } + } + } + + val shapeOwnerGetShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "shape_owner_get_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_get_shape" } + } + } + + val shapeOwnerGetShapeCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "shape_owner_get_shape_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_get_shape_count" } + } + } + + val shapeOwnerGetShapeIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "shape_owner_get_shape_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_get_shape_index" } + } + } + + val shapeOwnerGetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "shape_owner_get_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_get_transform" } + } + } + + val shapeOwnerRemoveShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "shape_owner_remove_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_remove_shape" } + } + } + + val shapeOwnerSetDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "shape_owner_set_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_set_disabled" } + } + } + + val shapeOwnerSetOneWayCollision: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "shape_owner_set_one_way_collision".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method shape_owner_set_one_way_collision" } + } + } + + val shapeOwnerSetOneWayCollisionMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "shape_owner_set_one_way_collision_margin".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method shape_owner_set_one_way_collision_margin" } + } + } + + val shapeOwnerSetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionObject2D".cstr.ptr, + "shape_owner_set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_owner_set_transform" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CollisionPolygon.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CollisionPolygon.kt index cb9988e3..726b94d4 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CollisionPolygon.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CollisionPolygon.kt @@ -141,47 +141,59 @@ open class CollisionPolygon( * Container for method_bind pointers for CollisionPolygon */ private object __method_bind { - val getDepth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon".cstr.ptr, - "get_depth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_depth" } - } - val getPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon".cstr.ptr, - "get_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_polygon" } - } - val isDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon".cstr.ptr, - "is_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_disabled" } - } - val setDepth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon".cstr.ptr, - "set_depth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_depth" } - } - val setDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon".cstr.ptr, - "set_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_disabled" } - } - val setPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon".cstr.ptr, - "set_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_polygon" } - }} + val getDepth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon".cstr.ptr, + "get_depth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_depth" } + } + } + + val getPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon".cstr.ptr, + "get_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_polygon" } + } + } + + val isDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon".cstr.ptr, + "is_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_disabled" } + } + } + + val setDepth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon".cstr.ptr, + "set_depth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_depth" } + } + } + + val setDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon".cstr.ptr, + "set_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_disabled" } + } + } + + val setPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon".cstr.ptr, + "set_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_polygon" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CollisionPolygon2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CollisionPolygon2D.kt index 11fbe0c8..8c196450 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CollisionPolygon2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CollisionPolygon2D.kt @@ -207,75 +207,95 @@ open class CollisionPolygon2D( * Container for method_bind pointers for CollisionPolygon2D */ private object __method_bind { - val getBuildMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, - "get_build_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_build_mode" } - } - val getOneWayCollisionMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, - "get_one_way_collision_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_one_way_collision_margin" } - } - val getPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, - "get_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_polygon" } - } - val isDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, - "is_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_disabled" } - } - val isOneWayCollisionEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, - "is_one_way_collision_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_one_way_collision_enabled" } - } - val setBuildMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, - "set_build_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_build_mode" } - } - val setDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, - "set_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_disabled" } - } - val setOneWayCollision: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, - "set_one_way_collision".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_one_way_collision" } - } - val setOneWayCollisionMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, - "set_one_way_collision_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_one_way_collision_margin" } - } - val setPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, - "set_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_polygon" } - }} + val getBuildMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, + "get_build_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_build_mode" } + } + } + + val getOneWayCollisionMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, + "get_one_way_collision_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_one_way_collision_margin" } + } + } + + val getPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, + "get_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_polygon" } + } + } + + val isDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, + "is_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_disabled" } + } + } + + val isOneWayCollisionEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, + "is_one_way_collision_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_one_way_collision_enabled" } + } + } + + val setBuildMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, + "set_build_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_build_mode" } + } + } + + val setDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, + "set_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_disabled" } + } + } + + val setOneWayCollision: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, + "set_one_way_collision".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_one_way_collision" } + } + } + + val setOneWayCollisionMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, + "set_one_way_collision_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_one_way_collision_margin" } + } + } + + val setPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionPolygon2D".cstr.ptr, + "set_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_polygon" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CollisionShape.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CollisionShape.kt index 125cb22a..1ab71548 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CollisionShape.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CollisionShape.kt @@ -123,47 +123,59 @@ open class CollisionShape( * Container for method_bind pointers for CollisionShape */ private object __method_bind { - val getShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape".cstr.ptr, - "get_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shape" } - } - val isDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape".cstr.ptr, - "is_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_disabled" } - } - val makeConvexFromBrothers: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape".cstr.ptr, - "make_convex_from_brothers".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method make_convex_from_brothers" } - } - val resourceChanged: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape".cstr.ptr, - "resource_changed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method resource_changed" } - } - val setDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape".cstr.ptr, - "set_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_disabled" } - } - val setShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape".cstr.ptr, - "set_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shape" } - }} + val getShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape".cstr.ptr, + "get_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shape" } + } + } + + val isDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape".cstr.ptr, + "is_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_disabled" } + } + } + + val makeConvexFromBrothers: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape".cstr.ptr, + "make_convex_from_brothers".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method make_convex_from_brothers" } + } + } + + val resourceChanged: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape".cstr.ptr, + "resource_changed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method resource_changed" } + } + } + + val setDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape".cstr.ptr, + "set_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_disabled" } + } + } + + val setShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape".cstr.ptr, + "set_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shape" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CollisionShape2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CollisionShape2D.kt index c5b9eca5..5b9a9237 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CollisionShape2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CollisionShape2D.kt @@ -156,61 +156,77 @@ open class CollisionShape2D( * Container for method_bind pointers for CollisionShape2D */ private object __method_bind { - val getOneWayCollisionMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape2D".cstr.ptr, - "get_one_way_collision_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_one_way_collision_margin" } - } - val getShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape2D".cstr.ptr, - "get_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shape" } - } - val isDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape2D".cstr.ptr, - "is_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_disabled" } - } - val isOneWayCollisionEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape2D".cstr.ptr, - "is_one_way_collision_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_one_way_collision_enabled" } - } - val setDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape2D".cstr.ptr, - "set_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_disabled" } - } - val setOneWayCollision: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape2D".cstr.ptr, - "set_one_way_collision".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_one_way_collision" } - } - val setOneWayCollisionMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape2D".cstr.ptr, - "set_one_way_collision_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_one_way_collision_margin" } - } - val setShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape2D".cstr.ptr, - "set_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shape" } - }} + val getOneWayCollisionMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape2D".cstr.ptr, + "get_one_way_collision_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_one_way_collision_margin" } + } + } + + val getShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape2D".cstr.ptr, + "get_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shape" } + } + } + + val isDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape2D".cstr.ptr, + "is_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_disabled" } + } + } + + val isOneWayCollisionEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape2D".cstr.ptr, + "is_one_way_collision_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_one_way_collision_enabled" } + } + } + + val setDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape2D".cstr.ptr, + "set_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_disabled" } + } + } + + val setOneWayCollision: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape2D".cstr.ptr, + "set_one_way_collision".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_one_way_collision" } + } + } + + val setOneWayCollisionMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape2D".cstr.ptr, + "set_one_way_collision_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_one_way_collision_margin" } + } + } + + val setShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CollisionShape2D".cstr.ptr, + "set_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shape" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ColorPicker.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ColorPicker.kt index 245986eb..48a05df3 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ColorPicker.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ColorPicker.kt @@ -338,124 +338,158 @@ open class ColorPicker( * Container for method_bind pointers for ColorPicker */ private object __method_bind { - val addPreset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, - "add_preset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_preset" } - } - val arePresetsEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, - "are_presets_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method are_presets_enabled" } - } - val arePresetsVisible: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, - "are_presets_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method are_presets_visible" } - } - val erasePreset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, - "erase_preset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method erase_preset" } - } - val getPickColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, - "get_pick_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pick_color" } - } - val getPresets: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, - "get_presets".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_presets" } - } - val isDeferredMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, - "is_deferred_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_deferred_mode" } - } - val isEditingAlpha: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, - "is_editing_alpha".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_editing_alpha" } - } - val isHsvMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, - "is_hsv_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_hsv_mode" } - } - val isRawMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, - "is_raw_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_raw_mode" } - } - val setDeferredMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, - "set_deferred_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_deferred_mode" } - } - val setEditAlpha: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, - "set_edit_alpha".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_edit_alpha" } - } - val setHsvMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, - "set_hsv_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_hsv_mode" } - } - val setPickColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, - "set_pick_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pick_color" } - } - val setPresetsEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, - "set_presets_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_presets_enabled" } - } - val setPresetsVisible: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, - "set_presets_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_presets_visible" } - } - val setRawMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, - "set_raw_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_raw_mode" } - }} + val addPreset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, + "add_preset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_preset" } + } + } + + val arePresetsEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, + "are_presets_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method are_presets_enabled" } + } + } + + val arePresetsVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, + "are_presets_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method are_presets_visible" } + } + } + + val erasePreset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, + "erase_preset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method erase_preset" } + } + } + + val getPickColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, + "get_pick_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pick_color" } + } + } + + val getPresets: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, + "get_presets".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_presets" } + } + } + + val isDeferredMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, + "is_deferred_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_deferred_mode" } + } + } + + val isEditingAlpha: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, + "is_editing_alpha".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_editing_alpha" } + } + } + + val isHsvMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, + "is_hsv_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_hsv_mode" } + } + } + + val isRawMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, + "is_raw_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_raw_mode" } + } + } + + val setDeferredMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, + "set_deferred_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_deferred_mode" } + } + } + + val setEditAlpha: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, + "set_edit_alpha".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_edit_alpha" } + } + } + + val setHsvMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, + "set_hsv_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_hsv_mode" } + } + } + + val setPickColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, + "set_pick_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pick_color" } + } + } + + val setPresetsEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, + "set_presets_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_presets_enabled" } + } + } + + val setPresetsVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, + "set_presets_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_presets_visible" } + } + } + + val setRawMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPicker".cstr.ptr, + "set_raw_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_raw_mode" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ColorPickerButton.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ColorPickerButton.kt index 004436c8..f86b8dcc 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ColorPickerButton.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ColorPickerButton.kt @@ -158,47 +158,59 @@ open class ColorPickerButton( * Container for method_bind pointers for ColorPickerButton */ private object __method_bind { - val getPickColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPickerButton".cstr.ptr, - "get_pick_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pick_color" } - } - val getPicker: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPickerButton".cstr.ptr, - "get_picker".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_picker" } - } - val getPopup: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPickerButton".cstr.ptr, - "get_popup".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_popup" } - } - val isEditingAlpha: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPickerButton".cstr.ptr, - "is_editing_alpha".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_editing_alpha" } - } - val setEditAlpha: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPickerButton".cstr.ptr, - "set_edit_alpha".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_edit_alpha" } - } - val setPickColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPickerButton".cstr.ptr, - "set_pick_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pick_color" } - }} + val getPickColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPickerButton".cstr.ptr, + "get_pick_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pick_color" } + } + } + + val getPicker: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPickerButton".cstr.ptr, + "get_picker".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_picker" } + } + } + + val getPopup: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPickerButton".cstr.ptr, + "get_popup".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_popup" } + } + } + + val isEditingAlpha: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPickerButton".cstr.ptr, + "is_editing_alpha".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_editing_alpha" } + } + } + + val setEditAlpha: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPickerButton".cstr.ptr, + "set_edit_alpha".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_edit_alpha" } + } + } + + val setPickColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorPickerButton".cstr.ptr, + "set_pick_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pick_color" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ColorRect.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ColorRect.kt index 9c96d897..caac6459 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ColorRect.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ColorRect.kt @@ -84,17 +84,23 @@ open class ColorRect( * Container for method_bind pointers for ColorRect */ private object __method_bind { - val getFrameColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorRect".cstr.ptr, - "get_frame_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_frame_color" } - } - val setFrameColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorRect".cstr.ptr, - "set_frame_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_frame_color" } - }} + val getFrameColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorRect".cstr.ptr, + "get_frame_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_frame_color" } + } + } + + val setFrameColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ColorRect".cstr.ptr, + "set_frame_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_frame_color" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ConcavePolygonShape.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ConcavePolygonShape.kt index 705019c9..bdc852a9 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ConcavePolygonShape.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ConcavePolygonShape.kt @@ -85,19 +85,23 @@ open class ConcavePolygonShape( * Container for method_bind pointers for ConcavePolygonShape */ private object __method_bind { - val getFaces: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConcavePolygonShape".cstr.ptr, - "get_faces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_faces" } - } - val setFaces: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConcavePolygonShape".cstr.ptr, - "set_faces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_faces" } - }} + val getFaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConcavePolygonShape".cstr.ptr, + "get_faces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_faces" } + } + } + + val setFaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConcavePolygonShape".cstr.ptr, + "set_faces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_faces" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ConcavePolygonShape2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ConcavePolygonShape2D.kt index e80d65b0..9856f774 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ConcavePolygonShape2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ConcavePolygonShape2D.kt @@ -85,19 +85,23 @@ open class ConcavePolygonShape2D( * Container for method_bind pointers for ConcavePolygonShape2D */ private object __method_bind { - val getSegments: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConcavePolygonShape2D".cstr.ptr, - "get_segments".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_segments" } - } - val setSegments: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConcavePolygonShape2D".cstr.ptr, - "set_segments".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_segments" } - }} + val getSegments: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConcavePolygonShape2D".cstr.ptr, + "get_segments".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_segments" } + } + } + + val setSegments: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConcavePolygonShape2D".cstr.ptr, + "set_segments".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_segments" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ConeTwistJoint.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ConeTwistJoint.kt index 294bd7f5..e24be9c2 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ConeTwistJoint.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ConeTwistJoint.kt @@ -137,19 +137,23 @@ open class ConeTwistJoint( * Container for method_bind pointers for ConeTwistJoint */ private object __method_bind { - val getParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConeTwistJoint".cstr.ptr, - "get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_param" } - } - val setParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConeTwistJoint".cstr.ptr, - "set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_param" } - }} + val getParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConeTwistJoint".cstr.ptr, + "get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_param" } + } + } + + val setParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConeTwistJoint".cstr.ptr, + "set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_param" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ConfigFile.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ConfigFile.kt index 24cc936a..31587d5c 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ConfigFile.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ConfigFile.kt @@ -219,89 +219,131 @@ open class ConfigFile( * Container for method_bind pointers for ConfigFile */ private object __method_bind { - val eraseSection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, - "erase_section".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method erase_section" } - } - val eraseSectionKey: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, - "erase_section_key".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method erase_section_key" } - } - val getSectionKeys: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, - "get_section_keys".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_section_keys" } - } - val getSections: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, - "get_sections".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sections" } - } - val getValue: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, - "get_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_value" } - } - val hasSection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, - "has_section".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_section" } - } - val hasSectionKey: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, - "has_section_key".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_section_key" } - } - val load: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, - "load".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method load" } - } - val loadEncrypted: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, - "load_encrypted".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method load_encrypted" } - } - val loadEncryptedPass: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, - "load_encrypted_pass".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method load_encrypted_pass" } - } - val save: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, - "save".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method save" } - } - val saveEncrypted: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, - "save_encrypted".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method save_encrypted" } - } - val saveEncryptedPass: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, - "save_encrypted_pass".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method save_encrypted_pass" } - } - val setValue: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, - "set_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_value" } - }} + val eraseSection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, + "erase_section".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method erase_section" } + } + } + + val eraseSectionKey: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, + "erase_section_key".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method erase_section_key" } + } + } + + val getSectionKeys: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, + "get_section_keys".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_section_keys" } + } + } + + val getSections: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, + "get_sections".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sections" } + } + } + + val getValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, + "get_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_value" } + } + } + + val hasSection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, + "has_section".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_section" } + } + } + + val hasSectionKey: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, + "has_section_key".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_section_key" } + } + } + + val load: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, + "load".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method load" } + } + } + + val loadEncrypted: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, + "load_encrypted".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method load_encrypted" } + } + } + + val loadEncryptedPass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, + "load_encrypted_pass".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method load_encrypted_pass" } + } + } + + val save: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, + "save".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method save" } + } + } + + val saveEncrypted: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, + "save_encrypted".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method save_encrypted" } + } + } + + val saveEncryptedPass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, + "save_encrypted_pass".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method save_encrypted_pass" } + } + } + + val setValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfigFile".cstr.ptr, + "set_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_value" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ConfirmationDialog.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ConfirmationDialog.kt index c3415d05..c6a39527 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ConfirmationDialog.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ConfirmationDialog.kt @@ -60,12 +60,14 @@ open class ConfirmationDialog( * Container for method_bind pointers for ConfirmationDialog */ private object __method_bind { - val getCancel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfirmationDialog".cstr.ptr, - "get_cancel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cancel" } - }} + val getCancel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConfirmationDialog".cstr.ptr, + "get_cancel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cancel" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Container.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Container.kt index 7a0bf15b..b8502a91 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Container.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Container.kt @@ -81,17 +81,23 @@ open class Container( * Container for method_bind pointers for Container */ private object __method_bind { - val fitChildInRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Container".cstr.ptr, - "fit_child_in_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method fit_child_in_rect" } - } - val queueSort: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Container".cstr.ptr, - "queue_sort".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method queue_sort" } - }} + val fitChildInRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Container".cstr.ptr, + "fit_child_in_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method fit_child_in_rect" } + } + } + + val queueSort: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Container".cstr.ptr, + "queue_sort".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method queue_sort" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Control.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Control.kt index de9642ef..fda69d39 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Control.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Control.kt @@ -1652,587 +1652,879 @@ open class Control( * Container for method_bind pointers for Control */ private object __method_bind { - val acceptEvent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "accept_event".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method accept_event" } - } - val addColorOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "add_color_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_color_override" } - } - val addConstantOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "add_constant_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_constant_override" } - } - val addFontOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "add_font_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_font_override" } - } - val addIconOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "add_icon_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_icon_override" } - } - val addShaderOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "add_shader_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_shader_override" } - } - val addStyleboxOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "add_stylebox_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_stylebox_override" } - } - val forceDrag: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "force_drag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method force_drag" } - } - val getAnchor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_anchor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_anchor" } - } - val getBegin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_begin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_begin" } - } - val getColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_color" } - } - val getCombinedMinimumSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_combined_minimum_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_combined_minimum_size" } - } - val getConstant: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_constant" } - } - val getCursorShape: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_cursor_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cursor_shape" } - } - val getCustomMinimumSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_custom_minimum_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_custom_minimum_size" } - } - val getDefaultCursorShape: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_default_cursor_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_default_cursor_shape" } - } - val getEnd: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_end".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_end" } - } - val getFocusMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_focus_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_focus_mode" } - } - val getFocusNeighbour: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_focus_neighbour".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_focus_neighbour" } - } - val getFocusNext: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_focus_next".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_focus_next" } - } - val getFocusOwner: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_focus_owner".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_focus_owner" } - } - val getFocusPrevious: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_focus_previous".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_focus_previous" } - } - val getFont: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_font".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_font" } - } - val getGlobalPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_global_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_global_position" } - } - val getGlobalRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_global_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_global_rect" } - } - val getHGrowDirection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_h_grow_direction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_h_grow_direction" } - } - val getHSizeFlags: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_h_size_flags".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_h_size_flags" } - } - val getIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_icon" } - } - val getMargin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_margin" } - } - val getMinimumSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_minimum_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_minimum_size" } - } - val getMouseFilter: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_mouse_filter".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mouse_filter" } - } - val getParentAreaSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_parent_area_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_parent_area_size" } - } - val getParentControl: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_parent_control".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_parent_control" } - } - val getPivotOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_pivot_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pivot_offset" } - } - val getPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_position" } - } - val getRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rect" } - } - val getRotation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rotation" } - } - val getRotationDegrees: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_rotation_degrees".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rotation_degrees" } - } - val getScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_scale" } - } - val getSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_size" } - } - val getStretchRatio: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_stretch_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stretch_ratio" } - } - val getStylebox: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_stylebox".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stylebox" } - } - val getTheme: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_theme".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_theme" } - } - val getTooltip: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_tooltip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tooltip" } - } - val getVGrowDirection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_v_grow_direction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_v_grow_direction" } - } - val getVSizeFlags: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "get_v_size_flags".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_v_size_flags" } - } - val grabClickFocus: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "grab_click_focus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method grab_click_focus" } - } - val grabFocus: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "grab_focus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method grab_focus" } - } - val hasColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "has_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_color" } - } - val hasColorOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "has_color_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_color_override" } - } - val hasConstant: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "has_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_constant" } - } - val hasConstantOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "has_constant_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_constant_override" } - } - val hasFocus: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "has_focus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_focus" } - } - val hasFont: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "has_font".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_font" } - } - val hasFontOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "has_font_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_font_override" } - } - val hasIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "has_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_icon" } - } - val hasIconOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "has_icon_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_icon_override" } - } - val hasShaderOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "has_shader_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_shader_override" } - } - val hasStylebox: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "has_stylebox".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_stylebox" } - } - val hasStyleboxOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "has_stylebox_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_stylebox_override" } - } - val isClippingContents: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "is_clipping_contents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_clipping_contents" } - } - val minimumSizeChanged: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "minimum_size_changed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method minimum_size_changed" } - } - val releaseFocus: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "release_focus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method release_focus" } - } - val setAnchor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_anchor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_anchor" } - } - val setAnchorAndMargin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_anchor_and_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_anchor_and_margin" } - } - val setAnchorsAndMarginsPreset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_anchors_and_margins_preset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_anchors_and_margins_preset" } - } - val setAnchorsPreset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_anchors_preset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_anchors_preset" } - } - val setBegin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_begin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_begin" } - } - val setClipContents: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_clip_contents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_clip_contents" } - } - val setCustomMinimumSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_custom_minimum_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_custom_minimum_size" } - } - val setDefaultCursorShape: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_default_cursor_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_default_cursor_shape" } - } - val setDragForwarding: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_drag_forwarding".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_drag_forwarding" } - } - val setDragPreview: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_drag_preview".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_drag_preview" } - } - val setEnd: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_end".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_end" } - } - val setFocusMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_focus_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_focus_mode" } - } - val setFocusNeighbour: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_focus_neighbour".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_focus_neighbour" } - } - val setFocusNext: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_focus_next".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_focus_next" } - } - val setFocusPrevious: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_focus_previous".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_focus_previous" } - } - val setGlobalPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_global_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_global_position" } - } - val setHGrowDirection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_h_grow_direction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_h_grow_direction" } - } - val setHSizeFlags: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_h_size_flags".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_h_size_flags" } - } - val setMargin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_margin" } - } - val setMarginsPreset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_margins_preset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_margins_preset" } - } - val setMouseFilter: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_mouse_filter".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mouse_filter" } - } - val setPivotOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_pivot_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pivot_offset" } - } - val setPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_position" } - } - val setRotation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rotation" } - } - val setRotationDegrees: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_rotation_degrees".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rotation_degrees" } - } - val setScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_scale" } - } - val setSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_size" } - } - val setStretchRatio: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_stretch_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_stretch_ratio" } - } - val setTheme: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_theme".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_theme" } - } - val setTooltip: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_tooltip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tooltip" } - } - val setVGrowDirection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_v_grow_direction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_v_grow_direction" } - } - val setVSizeFlags: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "set_v_size_flags".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_v_size_flags" } - } - val showModal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "show_modal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method show_modal" } - } - val warpMouse: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, - "warp_mouse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method warp_mouse" } - }} + val acceptEvent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "accept_event".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method accept_event" } + } + } + + val addColorOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "add_color_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_color_override" } + } + } + + val addConstantOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "add_constant_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_constant_override" } + } + } + + val addFontOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "add_font_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_font_override" } + } + } + + val addIconOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "add_icon_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_icon_override" } + } + } + + val addShaderOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "add_shader_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_shader_override" } + } + } + + val addStyleboxOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "add_stylebox_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_stylebox_override" } + } + } + + val forceDrag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "force_drag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method force_drag" } + } + } + + val getAnchor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_anchor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_anchor" } + } + } + + val getBegin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_begin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_begin" } + } + } + + val getColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_color" } + } + } + + val getCombinedMinimumSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_combined_minimum_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_combined_minimum_size" } + } + } + + val getConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_constant" } + } + } + + val getCursorShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_cursor_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cursor_shape" } + } + } + + val getCustomMinimumSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_custom_minimum_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_custom_minimum_size" } + } + } + + val getDefaultCursorShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_default_cursor_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_default_cursor_shape" } + } + } + + val getEnd: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_end".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_end" } + } + } + + val getFocusMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_focus_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_focus_mode" } + } + } + + val getFocusNeighbour: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_focus_neighbour".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_focus_neighbour" } + } + } + + val getFocusNext: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_focus_next".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_focus_next" } + } + } + + val getFocusOwner: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_focus_owner".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_focus_owner" } + } + } + + val getFocusPrevious: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_focus_previous".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_focus_previous" } + } + } + + val getFont: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_font".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_font" } + } + } + + val getGlobalPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_global_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_global_position" } + } + } + + val getGlobalRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_global_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_global_rect" } + } + } + + val getHGrowDirection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_h_grow_direction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_h_grow_direction" } + } + } + + val getHSizeFlags: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_h_size_flags".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_h_size_flags" } + } + } + + val getIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_icon" } + } + } + + val getMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_margin" } + } + } + + val getMinimumSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_minimum_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_minimum_size" } + } + } + + val getMouseFilter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_mouse_filter".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mouse_filter" } + } + } + + val getParentAreaSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_parent_area_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_parent_area_size" } + } + } + + val getParentControl: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_parent_control".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_parent_control" } + } + } + + val getPivotOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_pivot_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pivot_offset" } + } + } + + val getPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_position" } + } + } + + val getRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rect" } + } + } + + val getRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rotation" } + } + } + + val getRotationDegrees: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_rotation_degrees".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rotation_degrees" } + } + } + + val getScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_scale" } + } + } + + val getSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_size" } + } + } + + val getStretchRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_stretch_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stretch_ratio" } + } + } + + val getStylebox: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_stylebox".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stylebox" } + } + } + + val getTheme: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_theme".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_theme" } + } + } + + val getTooltip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_tooltip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tooltip" } + } + } + + val getVGrowDirection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_v_grow_direction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_v_grow_direction" } + } + } + + val getVSizeFlags: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "get_v_size_flags".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_v_size_flags" } + } + } + + val grabClickFocus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "grab_click_focus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method grab_click_focus" } + } + } + + val grabFocus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "grab_focus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method grab_focus" } + } + } + + val hasColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "has_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_color" } + } + } + + val hasColorOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "has_color_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_color_override" } + } + } + + val hasConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "has_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_constant" } + } + } + + val hasConstantOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "has_constant_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_constant_override" } + } + } + + val hasFocus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "has_focus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_focus" } + } + } + + val hasFont: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "has_font".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_font" } + } + } + + val hasFontOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "has_font_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_font_override" } + } + } + + val hasIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "has_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_icon" } + } + } + + val hasIconOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "has_icon_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_icon_override" } + } + } + + val hasShaderOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "has_shader_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_shader_override" } + } + } + + val hasStylebox: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "has_stylebox".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_stylebox" } + } + } + + val hasStyleboxOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "has_stylebox_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_stylebox_override" } + } + } + + val isClippingContents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "is_clipping_contents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_clipping_contents" } + } + } + + val minimumSizeChanged: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "minimum_size_changed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method minimum_size_changed" } + } + } + + val releaseFocus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "release_focus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method release_focus" } + } + } + + val setAnchor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_anchor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_anchor" } + } + } + + val setAnchorAndMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_anchor_and_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_anchor_and_margin" } + } + } + + val setAnchorsAndMarginsPreset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_anchors_and_margins_preset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_anchors_and_margins_preset" + } + } + } + + val setAnchorsPreset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_anchors_preset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_anchors_preset" } + } + } + + val setBegin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_begin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_begin" } + } + } + + val setClipContents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_clip_contents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_clip_contents" } + } + } + + val setCustomMinimumSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_custom_minimum_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_custom_minimum_size" } + } + } + + val setDefaultCursorShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_default_cursor_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_default_cursor_shape" } + } + } + + val setDragForwarding: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_drag_forwarding".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_drag_forwarding" } + } + } + + val setDragPreview: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_drag_preview".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_drag_preview" } + } + } + + val setEnd: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_end".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_end" } + } + } + + val setFocusMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_focus_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_focus_mode" } + } + } + + val setFocusNeighbour: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_focus_neighbour".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_focus_neighbour" } + } + } + + val setFocusNext: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_focus_next".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_focus_next" } + } + } + + val setFocusPrevious: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_focus_previous".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_focus_previous" } + } + } + + val setGlobalPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_global_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_global_position" } + } + } + + val setHGrowDirection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_h_grow_direction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_h_grow_direction" } + } + } + + val setHSizeFlags: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_h_size_flags".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_h_size_flags" } + } + } + + val setMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_margin" } + } + } + + val setMarginsPreset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_margins_preset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_margins_preset" } + } + } + + val setMouseFilter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_mouse_filter".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mouse_filter" } + } + } + + val setPivotOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_pivot_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pivot_offset" } + } + } + + val setPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_position" } + } + } + + val setRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rotation" } + } + } + + val setRotationDegrees: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_rotation_degrees".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rotation_degrees" } + } + } + + val setScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_scale" } + } + } + + val setSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_size" } + } + } + + val setStretchRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_stretch_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_stretch_ratio" } + } + } + + val setTheme: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_theme".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_theme" } + } + } + + val setTooltip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_tooltip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tooltip" } + } + } + + val setVGrowDirection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_v_grow_direction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_v_grow_direction" } + } + } + + val setVSizeFlags: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "set_v_size_flags".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_v_size_flags" } + } + } + + val showModal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "show_modal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method show_modal" } + } + } + + val warpMouse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Control".cstr.ptr, + "warp_mouse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method warp_mouse" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ConvexPolygonShape.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ConvexPolygonShape.kt index 993a3c68..ac6dfd18 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ConvexPolygonShape.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ConvexPolygonShape.kt @@ -85,19 +85,23 @@ open class ConvexPolygonShape( * Container for method_bind pointers for ConvexPolygonShape */ private object __method_bind { - val getPoints: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConvexPolygonShape".cstr.ptr, - "get_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_points" } - } - val setPoints: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConvexPolygonShape".cstr.ptr, - "set_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_points" } - }} + val getPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConvexPolygonShape".cstr.ptr, + "get_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_points" } + } + } + + val setPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConvexPolygonShape".cstr.ptr, + "set_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_points" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ConvexPolygonShape2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ConvexPolygonShape2D.kt index 5d8a1454..ed46a567 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ConvexPolygonShape2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ConvexPolygonShape2D.kt @@ -92,26 +92,32 @@ open class ConvexPolygonShape2D( * Container for method_bind pointers for ConvexPolygonShape2D */ private object __method_bind { - val getPoints: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConvexPolygonShape2D".cstr.ptr, - "get_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_points" } - } - val setPointCloud: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConvexPolygonShape2D".cstr.ptr, - "set_point_cloud".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_cloud" } - } - val setPoints: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConvexPolygonShape2D".cstr.ptr, - "set_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_points" } - }} + val getPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConvexPolygonShape2D".cstr.ptr, + "get_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_points" } + } + } + + val setPointCloud: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConvexPolygonShape2D".cstr.ptr, + "set_point_cloud".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_cloud" } + } + } + + val setPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ConvexPolygonShape2D".cstr.ptr, + "set_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_points" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Crypto.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Crypto.kt index f3311f0a..bb96bb1a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Crypto.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Crypto.kt @@ -94,23 +94,30 @@ open class Crypto( * Container for method_bind pointers for Crypto */ private object __method_bind { - val generateRandomBytes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Crypto".cstr.ptr, - "generate_random_bytes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method generate_random_bytes" } - } - val generateRsa: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Crypto".cstr.ptr, - "generate_rsa".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method generate_rsa" } - } - val generateSelfSignedCertificate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Crypto".cstr.ptr, - "generate_self_signed_certificate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method generate_self_signed_certificate" } - }} + val generateRandomBytes: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Crypto".cstr.ptr, + "generate_random_bytes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method generate_random_bytes" } + } + } + + val generateRsa: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Crypto".cstr.ptr, + "generate_rsa".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method generate_rsa" } + } + } + + val generateSelfSignedCertificate: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Crypto".cstr.ptr, + "generate_self_signed_certificate".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method generate_self_signed_certificate" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CryptoKey.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CryptoKey.kt index 3cf36e08..e0beff28 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CryptoKey.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CryptoKey.kt @@ -68,17 +68,23 @@ open class CryptoKey( * Container for method_bind pointers for CryptoKey */ private object __method_bind { - val load: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CryptoKey".cstr.ptr, - "load".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method load" } - } - val save: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CryptoKey".cstr.ptr, - "save".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method save" } - }} + val load: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CryptoKey".cstr.ptr, + "load".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method load" } + } + } + + val save: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CryptoKey".cstr.ptr, + "save".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method save" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CubeMap.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CubeMap.kt index 504cbd0f..7a017d0a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CubeMap.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CubeMap.kt @@ -237,65 +237,95 @@ open class CubeMap( * Container for method_bind pointers for CubeMap */ private object __method_bind { - val getFlags: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, - "get_flags".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_flags" } - } - val getHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, - "get_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_height" } - } - val getLossyStorageQuality: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, - "get_lossy_storage_quality".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_lossy_storage_quality" } - } - val getSide: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, - "get_side".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_side" } - } - val getStorage: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, - "get_storage".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_storage" } - } - val getWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, - "get_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_width" } - } - val setFlags: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, - "set_flags".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flags" } - } - val setLossyStorageQuality: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, - "set_lossy_storage_quality".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_lossy_storage_quality" } - } - val setSide: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, - "set_side".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_side" } - } - val setStorage: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, - "set_storage".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_storage" } - }} + val getFlags: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, + "get_flags".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_flags" } + } + } + + val getHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, + "get_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_height" } + } + } + + val getLossyStorageQuality: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, + "get_lossy_storage_quality".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_lossy_storage_quality" } + } + } + + val getSide: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, + "get_side".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_side" } + } + } + + val getStorage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, + "get_storage".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_storage" } + } + } + + val getWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, + "get_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_width" } + } + } + + val setFlags: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, + "set_flags".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flags" } + } + } + + val setLossyStorageQuality: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, + "set_lossy_storage_quality".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_lossy_storage_quality" } + } + } + + val setSide: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, + "set_side".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_side" } + } + } + + val setStorage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMap".cstr.ptr, + "set_storage".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_storage" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CubeMesh.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CubeMesh.kt index 7ccf2d69..bb59dc85 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CubeMesh.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CubeMesh.kt @@ -160,53 +160,77 @@ open class CubeMesh( * Container for method_bind pointers for CubeMesh */ private object __method_bind { - val getSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMesh".cstr.ptr, - "get_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_size" } - } - val getSubdivideDepth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMesh".cstr.ptr, - "get_subdivide_depth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_subdivide_depth" } - } - val getSubdivideHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMesh".cstr.ptr, - "get_subdivide_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_subdivide_height" } - } - val getSubdivideWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMesh".cstr.ptr, - "get_subdivide_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_subdivide_width" } - } - val setSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMesh".cstr.ptr, - "set_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_size" } - } - val setSubdivideDepth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMesh".cstr.ptr, - "set_subdivide_depth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_subdivide_depth" } - } - val setSubdivideHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMesh".cstr.ptr, - "set_subdivide_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_subdivide_height" } - } - val setSubdivideWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMesh".cstr.ptr, - "set_subdivide_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_subdivide_width" } - }} + val getSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMesh".cstr.ptr, + "get_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_size" } + } + } + + val getSubdivideDepth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMesh".cstr.ptr, + "get_subdivide_depth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_subdivide_depth" } + } + } + + val getSubdivideHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMesh".cstr.ptr, + "get_subdivide_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_subdivide_height" } + } + } + + val getSubdivideWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMesh".cstr.ptr, + "get_subdivide_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_subdivide_width" } + } + } + + val setSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMesh".cstr.ptr, + "set_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_size" } + } + } + + val setSubdivideDepth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMesh".cstr.ptr, + "set_subdivide_depth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_subdivide_depth" } + } + } + + val setSubdivideHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMesh".cstr.ptr, + "set_subdivide_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_subdivide_height" } + } + } + + val setSubdivideWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CubeMesh".cstr.ptr, + "set_subdivide_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_subdivide_width" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Curve.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Curve.kt index df0ded96..a0ff1a3c 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Curve.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Curve.kt @@ -353,155 +353,205 @@ open class Curve( * Container for method_bind pointers for Curve */ private object __method_bind { - val addPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "add_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_point" } - } - val bake: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "bake".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method bake" } - } - val cleanDupes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "clean_dupes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clean_dupes" } - } - val clearPoints: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "clear_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_points" } - } - val getBakeResolution: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "get_bake_resolution".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bake_resolution" } - } - val getMaxValue: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "get_max_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_max_value" } - } - val getMinValue: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "get_min_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_min_value" } - } - val getPointCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "get_point_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_count" } - } - val getPointLeftMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "get_point_left_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_left_mode" } - } - val getPointLeftTangent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "get_point_left_tangent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_left_tangent" } - } - val getPointPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "get_point_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_position" } - } - val getPointRightMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "get_point_right_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_right_mode" } - } - val getPointRightTangent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "get_point_right_tangent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_right_tangent" } - } - val interpolate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "interpolate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method interpolate" } - } - val interpolateBaked: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "interpolate_baked".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method interpolate_baked" } - } - val removePoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "remove_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_point" } - } - val setBakeResolution: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "set_bake_resolution".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bake_resolution" } - } - val setMaxValue: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "set_max_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_max_value" } - } - val setMinValue: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "set_min_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_min_value" } - } - val setPointLeftMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "set_point_left_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_left_mode" } - } - val setPointLeftTangent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "set_point_left_tangent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_left_tangent" } - } - val setPointOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "set_point_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_offset" } - } - val setPointRightMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "set_point_right_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_right_mode" } - } - val setPointRightTangent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "set_point_right_tangent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_right_tangent" } - } - val setPointValue: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, - "set_point_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_value" } - }} + val addPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "add_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_point" } + } + } + + val bake: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "bake".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method bake" } + } + } + + val cleanDupes: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "clean_dupes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clean_dupes" } + } + } + + val clearPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "clear_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_points" } + } + } + + val getBakeResolution: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "get_bake_resolution".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bake_resolution" } + } + } + + val getMaxValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "get_max_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_max_value" } + } + } + + val getMinValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "get_min_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_min_value" } + } + } + + val getPointCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "get_point_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_count" } + } + } + + val getPointLeftMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "get_point_left_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_left_mode" } + } + } + + val getPointLeftTangent: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "get_point_left_tangent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_left_tangent" } + } + } + + val getPointPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "get_point_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_position" } + } + } + + val getPointRightMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "get_point_right_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_right_mode" } + } + } + + val getPointRightTangent: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "get_point_right_tangent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_right_tangent" } + } + } + + val interpolate: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "interpolate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method interpolate" } + } + } + + val interpolateBaked: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "interpolate_baked".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method interpolate_baked" } + } + } + + val removePoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "remove_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_point" } + } + } + + val setBakeResolution: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "set_bake_resolution".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bake_resolution" } + } + } + + val setMaxValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "set_max_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_max_value" } + } + } + + val setMinValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "set_min_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_min_value" } + } + } + + val setPointLeftMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "set_point_left_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_left_mode" } + } + } + + val setPointLeftTangent: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "set_point_left_tangent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_left_tangent" } + } + } + + val setPointOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "set_point_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_offset" } + } + } + + val setPointRightMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "set_point_right_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_right_mode" } + } + } + + val setPointRightTangent: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "set_point_right_tangent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_right_tangent" } + } + } + + val setPointValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve".cstr.ptr, + "set_point_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_value" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Curve2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Curve2D.kt index 5329ef0d..26a1f7e8 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Curve2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Curve2D.kt @@ -285,125 +285,185 @@ open class Curve2D( * Container for method_bind pointers for Curve2D */ private object __method_bind { - val addPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "add_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_point" } - } - val clearPoints: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "clear_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_points" } - } - val getBakeInterval: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "get_bake_interval".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bake_interval" } - } - val getBakedLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "get_baked_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_baked_length" } - } - val getBakedPoints: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "get_baked_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_baked_points" } - } - val getClosestOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "get_closest_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_closest_offset" } - } - val getClosestPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "get_closest_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_closest_point" } - } - val getPointCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "get_point_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_count" } - } - val getPointIn: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "get_point_in".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_in" } - } - val getPointOut: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "get_point_out".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_out" } - } - val getPointPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "get_point_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_position" } - } - val interpolate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "interpolate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method interpolate" } - } - val interpolateBaked: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "interpolate_baked".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method interpolate_baked" } - } - val interpolatef: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "interpolatef".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method interpolatef" } - } - val removePoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "remove_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_point" } - } - val setBakeInterval: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "set_bake_interval".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bake_interval" } - } - val setPointIn: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "set_point_in".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_in" } - } - val setPointOut: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "set_point_out".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_out" } - } - val setPointPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "set_point_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_position" } - } - val tessellate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, - "tessellate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tessellate" } - }} + val addPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "add_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_point" } + } + } + + val clearPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "clear_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_points" } + } + } + + val getBakeInterval: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "get_bake_interval".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bake_interval" } + } + } + + val getBakedLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "get_baked_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_baked_length" } + } + } + + val getBakedPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "get_baked_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_baked_points" } + } + } + + val getClosestOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "get_closest_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_closest_offset" } + } + } + + val getClosestPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "get_closest_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_closest_point" } + } + } + + val getPointCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "get_point_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_count" } + } + } + + val getPointIn: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "get_point_in".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_in" } + } + } + + val getPointOut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "get_point_out".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_out" } + } + } + + val getPointPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "get_point_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_position" } + } + } + + val interpolate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "interpolate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method interpolate" } + } + } + + val interpolateBaked: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "interpolate_baked".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method interpolate_baked" } + } + } + + val interpolatef: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "interpolatef".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method interpolatef" } + } + } + + val removePoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "remove_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_point" } + } + } + + val setBakeInterval: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "set_bake_interval".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bake_interval" } + } + } + + val setPointIn: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "set_point_in".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_in" } + } + } + + val setPointOut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "set_point_out".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_out" } + } + } + + val setPointPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "set_point_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_position" } + } + } + + val tessellate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve2D".cstr.ptr, + "tessellate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tessellate" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Curve3D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Curve3D.kt index 73820925..bf05bfa2 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Curve3D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Curve3D.kt @@ -367,167 +367,248 @@ open class Curve3D( * Container for method_bind pointers for Curve3D */ private object __method_bind { - val addPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "add_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_point" } - } - val clearPoints: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "clear_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_points" } - } - val getBakeInterval: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "get_bake_interval".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bake_interval" } - } - val getBakedLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "get_baked_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_baked_length" } - } - val getBakedPoints: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "get_baked_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_baked_points" } - } - val getBakedTilts: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "get_baked_tilts".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_baked_tilts" } - } - val getBakedUpVectors: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "get_baked_up_vectors".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_baked_up_vectors" } - } - val getClosestOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "get_closest_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_closest_offset" } - } - val getClosestPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "get_closest_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_closest_point" } - } - val getPointCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "get_point_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_count" } - } - val getPointIn: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "get_point_in".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_in" } - } - val getPointOut: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "get_point_out".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_out" } - } - val getPointPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "get_point_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_position" } - } - val getPointTilt: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "get_point_tilt".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_tilt" } - } - val interpolate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "interpolate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method interpolate" } - } - val interpolateBaked: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "interpolate_baked".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method interpolate_baked" } - } - val interpolateBakedUpVector: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "interpolate_baked_up_vector".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method interpolate_baked_up_vector" } - } - val interpolatef: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "interpolatef".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method interpolatef" } - } - val isUpVectorEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "is_up_vector_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_up_vector_enabled" } - } - val removePoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "remove_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_point" } - } - val setBakeInterval: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "set_bake_interval".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bake_interval" } - } - val setPointIn: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "set_point_in".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_in" } - } - val setPointOut: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "set_point_out".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_out" } - } - val setPointPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "set_point_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_position" } - } - val setPointTilt: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "set_point_tilt".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_tilt" } - } - val setUpVectorEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "set_up_vector_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_up_vector_enabled" } - } - val tessellate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, - "tessellate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tessellate" } - }} + val addPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "add_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_point" } + } + } + + val clearPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "clear_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_points" } + } + } + + val getBakeInterval: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "get_bake_interval".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bake_interval" } + } + } + + val getBakedLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "get_baked_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_baked_length" } + } + } + + val getBakedPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "get_baked_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_baked_points" } + } + } + + val getBakedTilts: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "get_baked_tilts".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_baked_tilts" } + } + } + + val getBakedUpVectors: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "get_baked_up_vectors".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_baked_up_vectors" } + } + } + + val getClosestOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "get_closest_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_closest_offset" } + } + } + + val getClosestPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "get_closest_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_closest_point" } + } + } + + val getPointCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "get_point_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_count" } + } + } + + val getPointIn: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "get_point_in".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_in" } + } + } + + val getPointOut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "get_point_out".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_out" } + } + } + + val getPointPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "get_point_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_position" } + } + } + + val getPointTilt: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "get_point_tilt".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_tilt" } + } + } + + val interpolate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "interpolate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method interpolate" } + } + } + + val interpolateBaked: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "interpolate_baked".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method interpolate_baked" } + } + } + + val interpolateBakedUpVector: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "interpolate_baked_up_vector".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method interpolate_baked_up_vector" } + } + } + + val interpolatef: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "interpolatef".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method interpolatef" } + } + } + + val isUpVectorEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "is_up_vector_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_up_vector_enabled" } + } + } + + val removePoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "remove_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_point" } + } + } + + val setBakeInterval: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "set_bake_interval".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bake_interval" } + } + } + + val setPointIn: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "set_point_in".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_in" } + } + } + + val setPointOut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "set_point_out".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_out" } + } + } + + val setPointPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "set_point_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_position" } + } + } + + val setPointTilt: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "set_point_tilt".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_tilt" } + } + } + + val setUpVectorEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "set_up_vector_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_up_vector_enabled" } + } + } + + val tessellate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Curve3D".cstr.ptr, + "tessellate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tessellate" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CurveTexture.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CurveTexture.kt index 2a4f621e..528ef04d 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CurveTexture.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CurveTexture.kt @@ -94,26 +94,32 @@ open class CurveTexture( * Container for method_bind pointers for CurveTexture */ private object __method_bind { - val getCurve: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CurveTexture".cstr.ptr, - "get_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_curve" } - } - val setCurve: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CurveTexture".cstr.ptr, - "set_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_curve" } - } - val setWidth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CurveTexture".cstr.ptr, - "set_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_width" } - }} + val getCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CurveTexture".cstr.ptr, + "get_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_curve" } + } + } + + val setCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CurveTexture".cstr.ptr, + "set_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_curve" } + } + } + + val setWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CurveTexture".cstr.ptr, + "set_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_width" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CylinderMesh.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CylinderMesh.kt index bb516382..495ca6ed 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CylinderMesh.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CylinderMesh.kt @@ -174,75 +174,95 @@ open class CylinderMesh( * Container for method_bind pointers for CylinderMesh */ private object __method_bind { - val getBottomRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, - "get_bottom_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bottom_radius" } - } - val getHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, - "get_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_height" } - } - val getRadialSegments: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, - "get_radial_segments".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_radial_segments" } - } - val getRings: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, - "get_rings".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rings" } - } - val getTopRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, - "get_top_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_top_radius" } - } - val setBottomRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, - "set_bottom_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bottom_radius" } - } - val setHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, - "set_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_height" } - } - val setRadialSegments: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, - "set_radial_segments".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_radial_segments" } - } - val setRings: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, - "set_rings".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rings" } - } - val setTopRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, - "set_top_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_top_radius" } - }} + val getBottomRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, + "get_bottom_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bottom_radius" } + } + } + + val getHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, + "get_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_height" } + } + } + + val getRadialSegments: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, + "get_radial_segments".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_radial_segments" } + } + } + + val getRings: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, + "get_rings".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rings" } + } + } + + val getTopRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, + "get_top_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_top_radius" } + } + } + + val setBottomRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, + "set_bottom_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bottom_radius" } + } + } + + val setHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, + "set_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_height" } + } + } + + val setRadialSegments: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, + "set_radial_segments".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_radial_segments" } + } + } + + val setRings: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, + "set_rings".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rings" } + } + } + + val setTopRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderMesh".cstr.ptr, + "set_top_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_top_radius" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/CylinderShape.kt b/godot-kotlin/src/nativeGen/kotlin/godot/CylinderShape.kt index 28db98d4..88139803 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/CylinderShape.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/CylinderShape.kt @@ -98,33 +98,41 @@ open class CylinderShape( * Container for method_bind pointers for CylinderShape */ private object __method_bind { - val getHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderShape".cstr.ptr, - "get_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_height" } - } - val getRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderShape".cstr.ptr, - "get_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_radius" } - } - val setHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderShape".cstr.ptr, - "set_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_height" } - } - val setRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderShape".cstr.ptr, - "set_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_radius" } - }} + val getHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderShape".cstr.ptr, + "get_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_height" } + } + } + + val getRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderShape".cstr.ptr, + "get_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_radius" } + } + } + + val setHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderShape".cstr.ptr, + "set_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_height" } + } + } + + val setRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("CylinderShape".cstr.ptr, + "set_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_radius" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/DampedSpringJoint2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/DampedSpringJoint2D.kt index dda134c4..0c3f5539 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/DampedSpringJoint2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/DampedSpringJoint2D.kt @@ -149,61 +149,77 @@ open class DampedSpringJoint2D( * Container for method_bind pointers for DampedSpringJoint2D */ private object __method_bind { - val getDamping: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DampedSpringJoint2D".cstr.ptr, - "get_damping".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_damping" } - } - val getLength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DampedSpringJoint2D".cstr.ptr, - "get_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_length" } - } - val getRestLength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DampedSpringJoint2D".cstr.ptr, - "get_rest_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rest_length" } - } - val getStiffness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DampedSpringJoint2D".cstr.ptr, - "get_stiffness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stiffness" } - } - val setDamping: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DampedSpringJoint2D".cstr.ptr, - "set_damping".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_damping" } - } - val setLength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DampedSpringJoint2D".cstr.ptr, - "set_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_length" } - } - val setRestLength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DampedSpringJoint2D".cstr.ptr, - "set_rest_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rest_length" } - } - val setStiffness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DampedSpringJoint2D".cstr.ptr, - "set_stiffness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_stiffness" } - }} + val getDamping: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DampedSpringJoint2D".cstr.ptr, + "get_damping".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_damping" } + } + } + + val getLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DampedSpringJoint2D".cstr.ptr, + "get_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_length" } + } + } + + val getRestLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DampedSpringJoint2D".cstr.ptr, + "get_rest_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rest_length" } + } + } + + val getStiffness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DampedSpringJoint2D".cstr.ptr, + "get_stiffness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stiffness" } + } + } + + val setDamping: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DampedSpringJoint2D".cstr.ptr, + "set_damping".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_damping" } + } + } + + val setLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DampedSpringJoint2D".cstr.ptr, + "set_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_length" } + } + } + + val setRestLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DampedSpringJoint2D".cstr.ptr, + "set_rest_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rest_length" } + } + } + + val setStiffness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DampedSpringJoint2D".cstr.ptr, + "set_stiffness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_stiffness" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/DirectionalLight.kt b/godot-kotlin/src/nativeGen/kotlin/godot/DirectionalLight.kt index c4ad91fd..461b9e89 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/DirectionalLight.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/DirectionalLight.kt @@ -214,47 +214,59 @@ open class DirectionalLight( * Container for method_bind pointers for DirectionalLight */ private object __method_bind { - val getShadowDepthRange: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DirectionalLight".cstr.ptr, - "get_shadow_depth_range".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shadow_depth_range" } - } - val getShadowMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DirectionalLight".cstr.ptr, - "get_shadow_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shadow_mode" } - } - val isBlendSplitsEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DirectionalLight".cstr.ptr, - "is_blend_splits_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_blend_splits_enabled" } - } - val setBlendSplits: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DirectionalLight".cstr.ptr, - "set_blend_splits".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_blend_splits" } - } - val setShadowDepthRange: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DirectionalLight".cstr.ptr, - "set_shadow_depth_range".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shadow_depth_range" } - } - val setShadowMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DirectionalLight".cstr.ptr, - "set_shadow_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shadow_mode" } - }} + val getShadowDepthRange: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DirectionalLight".cstr.ptr, + "get_shadow_depth_range".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shadow_depth_range" } + } + } + + val getShadowMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DirectionalLight".cstr.ptr, + "get_shadow_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shadow_mode" } + } + } + + val isBlendSplitsEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DirectionalLight".cstr.ptr, + "is_blend_splits_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_blend_splits_enabled" } + } + } + + val setBlendSplits: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DirectionalLight".cstr.ptr, + "set_blend_splits".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_blend_splits" } + } + } + + val setShadowDepthRange: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DirectionalLight".cstr.ptr, + "set_shadow_depth_range".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shadow_depth_range" } + } + } + + val setShadowMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DirectionalLight".cstr.ptr, + "set_shadow_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shadow_mode" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Directory.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Directory.kt index c2a48724..c5294197 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Directory.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Directory.kt @@ -239,113 +239,167 @@ open class Directory( * Container for method_bind pointers for Directory */ private object __method_bind { - val changeDir: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, - "change_dir".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method change_dir" } - } - val copy: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, - "copy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method copy" } - } - val currentIsDir: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, - "current_is_dir".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method current_is_dir" } - } - val dirExists: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, - "dir_exists".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method dir_exists" } - } - val fileExists: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, - "file_exists".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method file_exists" } - } - val getCurrentDir: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, - "get_current_dir".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_dir" } - } - val getCurrentDrive: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, - "get_current_drive".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_drive" } - } - val getDrive: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, - "get_drive".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_drive" } - } - val getDriveCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, - "get_drive_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_drive_count" } - } - val getNext: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, - "get_next".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_next" } - } - val getSpaceLeft: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, - "get_space_left".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_space_left" } - } - val listDirBegin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, - "list_dir_begin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method list_dir_begin" } - } - val listDirEnd: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, - "list_dir_end".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method list_dir_end" } - } - val makeDir: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, - "make_dir".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method make_dir" } - } - val makeDirRecursive: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, - "make_dir_recursive".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method make_dir_recursive" } - } - val open: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, - "open".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method open" } - } - val remove: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, - "remove".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove" } - } - val rename: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, - "rename".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rename" } - }} + val changeDir: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, + "change_dir".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method change_dir" } + } + } + + val copy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, + "copy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method copy" } + } + } + + val currentIsDir: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, + "current_is_dir".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method current_is_dir" } + } + } + + val dirExists: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, + "dir_exists".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method dir_exists" } + } + } + + val fileExists: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, + "file_exists".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method file_exists" } + } + } + + val getCurrentDir: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, + "get_current_dir".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_dir" } + } + } + + val getCurrentDrive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, + "get_current_drive".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_drive" } + } + } + + val getDrive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, + "get_drive".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_drive" } + } + } + + val getDriveCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, + "get_drive_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_drive_count" } + } + } + + val getNext: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, + "get_next".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_next" } + } + } + + val getSpaceLeft: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, + "get_space_left".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_space_left" } + } + } + + val listDirBegin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, + "list_dir_begin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method list_dir_begin" } + } + } + + val listDirEnd: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, + "list_dir_end".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method list_dir_end" } + } + } + + val makeDir: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, + "make_dir".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method make_dir" } + } + } + + val makeDirRecursive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, + "make_dir_recursive".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method make_dir_recursive" } + } + } + + val open: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, + "open".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method open" } + } + } + + val remove: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, + "remove".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove" } + } + } + + val rename: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Directory".cstr.ptr, + "rename".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rename" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/DynamicFont.kt b/godot-kotlin/src/nativeGen/kotlin/godot/DynamicFont.kt index 474870e8..a736a601 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/DynamicFont.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/DynamicFont.kt @@ -334,138 +334,176 @@ open class DynamicFont( * Container for method_bind pointers for DynamicFont */ private object __method_bind { - val addFallback: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, - "add_fallback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_fallback" } - } - val getFallback: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, - "get_fallback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fallback" } - } - val getFallbackCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, - "get_fallback_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fallback_count" } - } - val getFontData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, - "get_font_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_font_data" } - } - val getOutlineColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, - "get_outline_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_outline_color" } - } - val getOutlineSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, - "get_outline_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_outline_size" } - } - val getSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, - "get_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_size" } - } - val getSpacing: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, - "get_spacing".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_spacing" } - } - val getUseFilter: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, - "get_use_filter".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_use_filter" } - } - val getUseMipmaps: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, - "get_use_mipmaps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_use_mipmaps" } - } - val removeFallback: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, - "remove_fallback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_fallback" } - } - val setFallback: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, - "set_fallback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fallback" } - } - val setFontData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, - "set_font_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_font_data" } - } - val setOutlineColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, - "set_outline_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_outline_color" } - } - val setOutlineSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, - "set_outline_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_outline_size" } - } - val setSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, - "set_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_size" } - } - val setSpacing: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, - "set_spacing".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_spacing" } - } - val setUseFilter: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, - "set_use_filter".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_filter" } - } - val setUseMipmaps: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, - "set_use_mipmaps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_mipmaps" } - }} + val addFallback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, + "add_fallback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_fallback" } + } + } + + val getFallback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, + "get_fallback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fallback" } + } + } + + val getFallbackCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, + "get_fallback_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fallback_count" } + } + } + + val getFontData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, + "get_font_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_font_data" } + } + } + + val getOutlineColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, + "get_outline_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_outline_color" } + } + } + + val getOutlineSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, + "get_outline_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_outline_size" } + } + } + + val getSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, + "get_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_size" } + } + } + + val getSpacing: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, + "get_spacing".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_spacing" } + } + } + + val getUseFilter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, + "get_use_filter".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_use_filter" } + } + } + + val getUseMipmaps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, + "get_use_mipmaps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_use_mipmaps" } + } + } + + val removeFallback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, + "remove_fallback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_fallback" } + } + } + + val setFallback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, + "set_fallback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fallback" } + } + } + + val setFontData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, + "set_font_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_font_data" } + } + } + + val setOutlineColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, + "set_outline_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_outline_color" } + } + } + + val setOutlineSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, + "set_outline_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_outline_size" } + } + } + + val setSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, + "set_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_size" } + } + } + + val setSpacing: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, + "set_spacing".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_spacing" } + } + } + + val setUseFilter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, + "set_use_filter".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_filter" } + } + } + + val setUseMipmaps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFont".cstr.ptr, + "set_use_mipmaps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_mipmaps" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/DynamicFontData.kt b/godot-kotlin/src/nativeGen/kotlin/godot/DynamicFontData.kt index e3eb1ec3..0b4da307 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/DynamicFontData.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/DynamicFontData.kt @@ -147,47 +147,59 @@ open class DynamicFontData( * Container for method_bind pointers for DynamicFontData */ private object __method_bind { - val getFontPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFontData".cstr.ptr, - "get_font_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_font_path" } - } - val getHinting: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFontData".cstr.ptr, - "get_hinting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_hinting" } - } - val isAntialiased: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFontData".cstr.ptr, - "is_antialiased".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_antialiased" } - } - val setAntialiased: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFontData".cstr.ptr, - "set_antialiased".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_antialiased" } - } - val setFontPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFontData".cstr.ptr, - "set_font_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_font_path" } - } - val setHinting: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFontData".cstr.ptr, - "set_hinting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_hinting" } - }} + val getFontPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFontData".cstr.ptr, + "get_font_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_font_path" } + } + } + + val getHinting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFontData".cstr.ptr, + "get_hinting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_hinting" } + } + } + + val isAntialiased: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFontData".cstr.ptr, + "is_antialiased".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_antialiased" } + } + } + + val setAntialiased: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFontData".cstr.ptr, + "set_antialiased".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_antialiased" } + } + } + + val setFontPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFontData".cstr.ptr, + "set_font_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_font_path" } + } + } + + val setHinting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("DynamicFontData".cstr.ptr, + "set_hinting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_hinting" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorExportPlugin.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorExportPlugin.kt index 3b79af3b..ee4e7ee1 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorExportPlugin.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorExportPlugin.kt @@ -133,61 +133,77 @@ open class EditorExportPlugin( * Container for method_bind pointers for EditorExportPlugin */ private object __method_bind { - val addFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorExportPlugin".cstr.ptr, - "add_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_file" } - } - val addIosBundleFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorExportPlugin".cstr.ptr, - "add_ios_bundle_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_ios_bundle_file" } - } - val addIosCppCode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorExportPlugin".cstr.ptr, - "add_ios_cpp_code".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_ios_cpp_code" } - } - val addIosFramework: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorExportPlugin".cstr.ptr, - "add_ios_framework".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_ios_framework" } - } - val addIosLinkerFlags: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorExportPlugin".cstr.ptr, - "add_ios_linker_flags".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_ios_linker_flags" } - } - val addIosPlistContent: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorExportPlugin".cstr.ptr, - "add_ios_plist_content".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_ios_plist_content" } - } - val addSharedObject: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorExportPlugin".cstr.ptr, - "add_shared_object".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_shared_object" } - } - val skip: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorExportPlugin".cstr.ptr, - "skip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method skip" } - }} + val addFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorExportPlugin".cstr.ptr, + "add_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_file" } + } + } + + val addIosBundleFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorExportPlugin".cstr.ptr, + "add_ios_bundle_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_ios_bundle_file" } + } + } + + val addIosCppCode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorExportPlugin".cstr.ptr, + "add_ios_cpp_code".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_ios_cpp_code" } + } + } + + val addIosFramework: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorExportPlugin".cstr.ptr, + "add_ios_framework".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_ios_framework" } + } + } + + val addIosLinkerFlags: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorExportPlugin".cstr.ptr, + "add_ios_linker_flags".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_ios_linker_flags" } + } + } + + val addIosPlistContent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorExportPlugin".cstr.ptr, + "add_ios_plist_content".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_ios_plist_content" } + } + } + + val addSharedObject: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorExportPlugin".cstr.ptr, + "add_shared_object".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_shared_object" } + } + } + + val skip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorExportPlugin".cstr.ptr, + "skip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method skip" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorFeatureProfile.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorFeatureProfile.kt index 7be05999..70edeaed 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorFeatureProfile.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorFeatureProfile.kt @@ -194,82 +194,104 @@ open class EditorFeatureProfile( * Container for method_bind pointers for EditorFeatureProfile */ private object __method_bind { - val getFeatureName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, - "get_feature_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_feature_name" } - } - val isClassDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, - "is_class_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_class_disabled" } - } - val isClassEditorDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, - "is_class_editor_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_class_editor_disabled" } - } - val isClassPropertyDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, - "is_class_property_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_class_property_disabled" } - } - val isFeatureDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, - "is_feature_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_feature_disabled" } - } - val loadFromFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, - "load_from_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method load_from_file" } - } - val saveToFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, - "save_to_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method save_to_file" } - } - val setDisableClass: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, - "set_disable_class".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_disable_class" } - } - val setDisableClassEditor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, - "set_disable_class_editor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_disable_class_editor" } - } - val setDisableClassProperty: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, - "set_disable_class_property".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_disable_class_property" } - } - val setDisableFeature: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, - "set_disable_feature".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_disable_feature" } - }} + val getFeatureName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, + "get_feature_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_feature_name" } + } + } + + val isClassDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, + "is_class_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_class_disabled" } + } + } + + val isClassEditorDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, + "is_class_editor_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_class_editor_disabled" } + } + } + + val isClassPropertyDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, + "is_class_property_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_class_property_disabled" } + } + } + + val isFeatureDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, + "is_feature_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_feature_disabled" } + } + } + + val loadFromFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, + "load_from_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method load_from_file" } + } + } + + val saveToFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, + "save_to_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method save_to_file" } + } + } + + val setDisableClass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, + "set_disable_class".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_disable_class" } + } + } + + val setDisableClassEditor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, + "set_disable_class_editor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_disable_class_editor" } + } + } + + val setDisableClassProperty: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, + "set_disable_class_property".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_disable_class_property" } + } + } + + val setDisableFeature: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFeatureProfile".cstr.ptr, + "set_disable_feature".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_disable_feature" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorFileDialog.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorFileDialog.kt index 6295f3c6..da139a39 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorFileDialog.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorFileDialog.kt @@ -487,145 +487,187 @@ open class EditorFileDialog( * Container for method_bind pointers for EditorFileDialog */ private object __method_bind { - val addFilter: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "add_filter".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_filter" } - } - val clearFilters: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "clear_filters".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_filters" } - } - val getAccess: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "get_access".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_access" } - } - val getCurrentDir: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "get_current_dir".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_dir" } - } - val getCurrentFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "get_current_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_file" } - } - val getCurrentPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "get_current_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_path" } - } - val getDisplayMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "get_display_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_display_mode" } - } - val getMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "get_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mode" } - } - val getVbox: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "get_vbox".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vbox" } - } - val invalidate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "invalidate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method invalidate" } - } - val isOverwriteWarningDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "is_overwrite_warning_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_overwrite_warning_disabled" } - } - val isShowingHiddenFiles: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "is_showing_hidden_files".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_showing_hidden_files" } - } - val setAccess: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "set_access".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_access" } - } - val setCurrentDir: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "set_current_dir".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_current_dir" } - } - val setCurrentFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "set_current_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_current_file" } - } - val setCurrentPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "set_current_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_current_path" } - } - val setDisableOverwriteWarning: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "set_disable_overwrite_warning".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_disable_overwrite_warning" } - } - val setDisplayMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "set_display_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_display_mode" } - } - val setMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "set_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mode" } - } - val setShowHiddenFiles: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, - "set_show_hidden_files".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_show_hidden_files" } - }} + val addFilter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "add_filter".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_filter" } + } + } + + val clearFilters: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "clear_filters".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_filters" } + } + } + + val getAccess: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "get_access".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_access" } + } + } + + val getCurrentDir: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "get_current_dir".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_dir" } + } + } + + val getCurrentFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "get_current_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_file" } + } + } + + val getCurrentPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "get_current_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_path" } + } + } + + val getDisplayMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "get_display_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_display_mode" } + } + } + + val getMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "get_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mode" } + } + } + + val getVbox: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "get_vbox".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vbox" } + } + } + + val invalidate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "invalidate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method invalidate" } + } + } + + val isOverwriteWarningDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "is_overwrite_warning_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_overwrite_warning_disabled" + } + } + } + + val isShowingHiddenFiles: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "is_showing_hidden_files".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_showing_hidden_files" } + } + } + + val setAccess: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "set_access".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_access" } + } + } + + val setCurrentDir: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "set_current_dir".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_current_dir" } + } + } + + val setCurrentFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "set_current_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_current_file" } + } + } + + val setCurrentPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "set_current_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_current_path" } + } + } + + val setDisableOverwriteWarning: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "set_disable_overwrite_warning".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_disable_overwrite_warning" + } + } + } + + val setDisplayMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "set_display_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_display_mode" } + } + } + + val setMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "set_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mode" } + } + } + + val setShowHiddenFiles: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileDialog".cstr.ptr, + "set_show_hidden_files".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_show_hidden_files" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorFileSystem.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorFileSystem.kt index 2cae2884..2964d021 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorFileSystem.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorFileSystem.kt @@ -147,68 +147,86 @@ open class EditorFileSystem( * Container for method_bind pointers for EditorFileSystem */ private object __method_bind { - val getFileType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystem".cstr.ptr, - "get_file_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_file_type" } - } - val getFilesystem: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystem".cstr.ptr, - "get_filesystem".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_filesystem" } - } - val getFilesystemPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystem".cstr.ptr, - "get_filesystem_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_filesystem_path" } - } - val getScanningProgress: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystem".cstr.ptr, - "get_scanning_progress".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_scanning_progress" } - } - val isScanning: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystem".cstr.ptr, - "is_scanning".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_scanning" } - } - val scan: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystem".cstr.ptr, - "scan".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method scan" } - } - val scanSources: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystem".cstr.ptr, - "scan_sources".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method scan_sources" } - } - val updateFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystem".cstr.ptr, - "update_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method update_file" } - } - val updateScriptClasses: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystem".cstr.ptr, - "update_script_classes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method update_script_classes" } - }} + val getFileType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystem".cstr.ptr, + "get_file_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_file_type" } + } + } + + val getFilesystem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystem".cstr.ptr, + "get_filesystem".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_filesystem" } + } + } + + val getFilesystemPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystem".cstr.ptr, + "get_filesystem_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_filesystem_path" } + } + } + + val getScanningProgress: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystem".cstr.ptr, + "get_scanning_progress".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_scanning_progress" } + } + } + + val isScanning: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystem".cstr.ptr, + "is_scanning".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_scanning" } + } + } + + val scan: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystem".cstr.ptr, + "scan".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method scan" } + } + } + + val scanSources: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystem".cstr.ptr, + "scan_sources".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method scan_sources" } + } + } + + val updateFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystem".cstr.ptr, + "update_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method update_file" } + } + } + + val updateScriptClasses: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystem".cstr.ptr, + "update_script_classes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method update_script_classes" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorFileSystemDirectory.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorFileSystemDirectory.kt index 9045af62..9bdb1d7e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorFileSystemDirectory.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorFileSystemDirectory.kt @@ -194,103 +194,132 @@ open class EditorFileSystemDirectory( * Container for method_bind pointers for EditorFileSystemDirectory */ private object __method_bind { - val findDirIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, - "find_dir_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method find_dir_index" } - } - val findFileIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, - "find_file_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method find_file_index" } - } - val getFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, - "get_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_file" } - } - val getFileCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, - "get_file_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_file_count" } - } - val getFileImportIsValid: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, - "get_file_import_is_valid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_file_import_is_valid" } - } - val getFilePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, - "get_file_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_file_path" } - } - val getFileScriptClassExtends: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, - "get_file_script_class_extends".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_file_script_class_extends" } - } - val getFileScriptClassName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, - "get_file_script_class_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_file_script_class_name" } - } - val getFileType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, - "get_file_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_file_type" } - } - val getName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, - "get_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_name" } - } - val getParent: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, - "get_parent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_parent" } - } - val getPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, - "get_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_path" } - } - val getSubdir: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, - "get_subdir".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_subdir" } - } - val getSubdirCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, - "get_subdir_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_subdir_count" } - }} + val findDirIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, + "find_dir_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method find_dir_index" } + } + } + + val findFileIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, + "find_file_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method find_file_index" } + } + } + + val getFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, + "get_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_file" } + } + } + + val getFileCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, + "get_file_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_file_count" } + } + } + + val getFileImportIsValid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, + "get_file_import_is_valid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_file_import_is_valid" } + } + } + + val getFilePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, + "get_file_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_file_path" } + } + } + + val getFileScriptClassExtends: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, + "get_file_script_class_extends".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_file_script_class_extends" + } + } + } + + val getFileScriptClassName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, + "get_file_script_class_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_file_script_class_name" } + } + } + + val getFileType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, + "get_file_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_file_type" } + } + } + + val getName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, + "get_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_name" } + } + } + + val getParent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, + "get_parent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_parent" } + } + } + + val getPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, + "get_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_path" } + } + } + + val getSubdir: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, + "get_subdir".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_subdir" } + } + } + + val getSubdirCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorFileSystemDirectory".cstr.ptr, + "get_subdir_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_subdir_count" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorInspector.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorInspector.kt index f19b09c5..5f2d5aa4 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorInspector.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorInspector.kt @@ -157,12 +157,14 @@ open class EditorInspector( * Container for method_bind pointers for EditorInspector */ private object __method_bind { - val refresh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInspector".cstr.ptr, - "refresh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method refresh" } - }} + val refresh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInspector".cstr.ptr, + "refresh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method refresh" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorInspectorPlugin.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorInspectorPlugin.kt index fc07dd47..23142ba6 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorInspectorPlugin.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorInspectorPlugin.kt @@ -103,27 +103,33 @@ open class EditorInspectorPlugin( * Container for method_bind pointers for EditorInspectorPlugin */ private object __method_bind { - val addCustomControl: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInspectorPlugin".cstr.ptr, - "add_custom_control".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_custom_control" } - } - val addPropertyEditor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInspectorPlugin".cstr.ptr, - "add_property_editor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_property_editor" } - } - val addPropertyEditorForMultipleProperties: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInspectorPlugin".cstr.ptr, - "add_property_editor_for_multiple_properties".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method add_property_editor_for_multiple_properties" } - }} + val addCustomControl: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInspectorPlugin".cstr.ptr, + "add_custom_control".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_custom_control" } + } + } + + val addPropertyEditor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInspectorPlugin".cstr.ptr, + "add_property_editor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_property_editor" } + } + } + + val addPropertyEditorForMultipleProperties: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInspectorPlugin".cstr.ptr, + "add_property_editor_for_multiple_properties".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method add_property_editor_for_multiple_properties" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorInterface.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorInterface.kt index f2ac5c7c..7b09a565 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorInterface.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorInterface.kt @@ -291,173 +291,221 @@ open class EditorInterface( * Container for method_bind pointers for EditorInterface */ private object __method_bind { - val editResource: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "edit_resource".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method edit_resource" } - } - val getBaseControl: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "get_base_control".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base_control" } - } - val getCurrentPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "get_current_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_path" } - } - val getEditedSceneRoot: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "get_edited_scene_root".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_edited_scene_root" } - } - val getEditorSettings: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "get_editor_settings".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_editor_settings" } - } - val getEditorViewport: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "get_editor_viewport".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_editor_viewport" } - } - val getInspector: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "get_inspector".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_inspector" } - } - val getOpenScenes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "get_open_scenes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_open_scenes" } - } - val getResourceFilesystem: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "get_resource_filesystem".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_resource_filesystem" } - } - val getResourcePreviewer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "get_resource_previewer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_resource_previewer" } - } - val getScriptEditor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "get_script_editor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_script_editor" } - } - val getSelectedPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "get_selected_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_selected_path" } - } - val getSelection: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "get_selection".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_selection" } - } - val inspectObject: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "inspect_object".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method inspect_object" } - } - val isPluginEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "is_plugin_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_plugin_enabled" } - } - val makeMeshPreviews: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "make_mesh_previews".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method make_mesh_previews" } - } - val openSceneFromPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "open_scene_from_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method open_scene_from_path" } - } - val reloadSceneFromPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "reload_scene_from_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method reload_scene_from_path" } - } - val saveScene: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "save_scene".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method save_scene" } - } - val saveSceneAs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "save_scene_as".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method save_scene_as" } - } - val selectFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "select_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method select_file" } - } - val setDistractionFreeMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "set_distraction_free_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_distraction_free_mode" } - } - val setMainScreenEditor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "set_main_screen_editor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_main_screen_editor" } - } - val setPluginEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, - "set_plugin_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_plugin_enabled" } - }} + val editResource: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "edit_resource".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method edit_resource" } + } + } + + val getBaseControl: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "get_base_control".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base_control" } + } + } + + val getCurrentPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "get_current_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_path" } + } + } + + val getEditedSceneRoot: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "get_edited_scene_root".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_edited_scene_root" } + } + } + + val getEditorSettings: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "get_editor_settings".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_editor_settings" } + } + } + + val getEditorViewport: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "get_editor_viewport".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_editor_viewport" } + } + } + + val getInspector: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "get_inspector".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_inspector" } + } + } + + val getOpenScenes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "get_open_scenes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_open_scenes" } + } + } + + val getResourceFilesystem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "get_resource_filesystem".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_resource_filesystem" } + } + } + + val getResourcePreviewer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "get_resource_previewer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_resource_previewer" } + } + } + + val getScriptEditor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "get_script_editor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_script_editor" } + } + } + + val getSelectedPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "get_selected_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_selected_path" } + } + } + + val getSelection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "get_selection".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_selection" } + } + } + + val inspectObject: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "inspect_object".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method inspect_object" } + } + } + + val isPluginEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "is_plugin_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_plugin_enabled" } + } + } + + val makeMeshPreviews: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "make_mesh_previews".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method make_mesh_previews" } + } + } + + val openSceneFromPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "open_scene_from_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method open_scene_from_path" } + } + } + + val reloadSceneFromPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "reload_scene_from_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method reload_scene_from_path" } + } + } + + val saveScene: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "save_scene".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method save_scene" } + } + } + + val saveSceneAs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "save_scene_as".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method save_scene_as" } + } + } + + val selectFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "select_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method select_file" } + } + } + + val setDistractionFreeMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "set_distraction_free_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_distraction_free_mode" } + } + } + + val setMainScreenEditor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "set_main_screen_editor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_main_screen_editor" } + } + } + + val setPluginEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorInterface".cstr.ptr, + "set_plugin_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_plugin_enabled" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorNavigationMeshGenerator.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorNavigationMeshGenerator.kt index 7336c41d..89fd9606 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorNavigationMeshGenerator.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorNavigationMeshGenerator.kt @@ -58,19 +58,23 @@ open class EditorNavigationMeshGenerator( * Container for method_bind pointers for EditorNavigationMeshGenerator */ private object __method_bind { - val bake: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorNavigationMeshGenerator".cstr.ptr, - "bake".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method bake" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorNavigationMeshGenerator".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - }} + val bake: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorNavigationMeshGenerator".cstr.ptr, + "bake".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method bake" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorNavigationMeshGenerator".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorPlugin.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorPlugin.kt index 85c2df09..5d1d5e20 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorPlugin.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorPlugin.kt @@ -506,231 +506,298 @@ open class EditorPlugin( * Container for method_bind pointers for EditorPlugin */ private object __method_bind { - val addAutoloadSingleton: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "add_autoload_singleton".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_autoload_singleton" } - } - val addControlToBottomPanel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "add_control_to_bottom_panel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_control_to_bottom_panel" } - } - val addControlToContainer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "add_control_to_container".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_control_to_container" } - } - val addControlToDock: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "add_control_to_dock".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_control_to_dock" } - } - val addCustomType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "add_custom_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_custom_type" } - } - val addExportPlugin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "add_export_plugin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_export_plugin" } - } - val addImportPlugin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "add_import_plugin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_import_plugin" } - } - val addInspectorPlugin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "add_inspector_plugin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_inspector_plugin" } - } - val addSceneImportPlugin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "add_scene_import_plugin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_scene_import_plugin" } - } - val addSpatialGizmoPlugin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "add_spatial_gizmo_plugin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_spatial_gizmo_plugin" } - } - val addToolMenuItem: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "add_tool_menu_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_tool_menu_item" } - } - val addToolSubmenuItem: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "add_tool_submenu_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_tool_submenu_item" } - } - val getEditorInterface: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "get_editor_interface".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_editor_interface" } - } - val getScriptCreateDialog: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "get_script_create_dialog".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_script_create_dialog" } - } - val getUndoRedo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "get_undo_redo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_undo_redo" } - } - val hideBottomPanel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "hide_bottom_panel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method hide_bottom_panel" } - } - val makeBottomPanelItemVisible: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "make_bottom_panel_item_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method make_bottom_panel_item_visible" } - } - val queueSaveLayout: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "queue_save_layout".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method queue_save_layout" } - } - val removeAutoloadSingleton: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "remove_autoload_singleton".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_autoload_singleton" } - } - val removeControlFromBottomPanel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "remove_control_from_bottom_panel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_control_from_bottom_panel" } - } - val removeControlFromContainer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "remove_control_from_container".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_control_from_container" } - } - val removeControlFromDocks: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "remove_control_from_docks".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_control_from_docks" } - } - val removeCustomType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "remove_custom_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_custom_type" } - } - val removeExportPlugin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "remove_export_plugin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_export_plugin" } - } - val removeImportPlugin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "remove_import_plugin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_import_plugin" } - } - val removeInspectorPlugin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "remove_inspector_plugin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_inspector_plugin" } - } - val removeSceneImportPlugin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "remove_scene_import_plugin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_scene_import_plugin" } - } - val removeSpatialGizmoPlugin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "remove_spatial_gizmo_plugin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_spatial_gizmo_plugin" } - } - val removeToolMenuItem: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "remove_tool_menu_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_tool_menu_item" } - } - val setForceDrawOverForwardingEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "set_force_draw_over_forwarding_enabled".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method set_force_draw_over_forwarding_enabled" } - } - val setInputEventForwardingAlwaysEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "set_input_event_forwarding_always_enabled".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method set_input_event_forwarding_always_enabled" } - } - val updateOverlays: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, - "update_overlays".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method update_overlays" } - }} + val addAutoloadSingleton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "add_autoload_singleton".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_autoload_singleton" } + } + } + + val addControlToBottomPanel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "add_control_to_bottom_panel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_control_to_bottom_panel" } + } + } + + val addControlToContainer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "add_control_to_container".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_control_to_container" } + } + } + + val addControlToDock: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "add_control_to_dock".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_control_to_dock" } + } + } + + val addCustomType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "add_custom_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_custom_type" } + } + } + + val addExportPlugin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "add_export_plugin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_export_plugin" } + } + } + + val addImportPlugin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "add_import_plugin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_import_plugin" } + } + } + + val addInspectorPlugin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "add_inspector_plugin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_inspector_plugin" } + } + } + + val addSceneImportPlugin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "add_scene_import_plugin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_scene_import_plugin" } + } + } + + val addSpatialGizmoPlugin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "add_spatial_gizmo_plugin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_spatial_gizmo_plugin" } + } + } + + val addToolMenuItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "add_tool_menu_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_tool_menu_item" } + } + } + + val addToolSubmenuItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "add_tool_submenu_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_tool_submenu_item" } + } + } + + val getEditorInterface: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "get_editor_interface".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_editor_interface" } + } + } + + val getScriptCreateDialog: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "get_script_create_dialog".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_script_create_dialog" } + } + } + + val getUndoRedo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "get_undo_redo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_undo_redo" } + } + } + + val hideBottomPanel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "hide_bottom_panel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method hide_bottom_panel" } + } + } + + val makeBottomPanelItemVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "make_bottom_panel_item_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method make_bottom_panel_item_visible" + } + } + } + + val queueSaveLayout: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "queue_save_layout".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method queue_save_layout" } + } + } + + val removeAutoloadSingleton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "remove_autoload_singleton".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_autoload_singleton" } + } + } + + val removeControlFromBottomPanel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "remove_control_from_bottom_panel".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method remove_control_from_bottom_panel" } + } + } + + val removeControlFromContainer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "remove_control_from_container".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_control_from_container" + } + } + } + + val removeControlFromDocks: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "remove_control_from_docks".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_control_from_docks" } + } + } + + val removeCustomType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "remove_custom_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_custom_type" } + } + } + + val removeExportPlugin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "remove_export_plugin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_export_plugin" } + } + } + + val removeImportPlugin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "remove_import_plugin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_import_plugin" } + } + } + + val removeInspectorPlugin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "remove_inspector_plugin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_inspector_plugin" } + } + } + + val removeSceneImportPlugin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "remove_scene_import_plugin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_scene_import_plugin" } + } + } + + val removeSpatialGizmoPlugin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "remove_spatial_gizmo_plugin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_spatial_gizmo_plugin" } + } + } + + val removeToolMenuItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "remove_tool_menu_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_tool_menu_item" } + } + } + + val setForceDrawOverForwardingEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "set_force_draw_over_forwarding_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_force_draw_over_forwarding_enabled" } + } + } + + val setInputEventForwardingAlwaysEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "set_input_event_forwarding_always_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_input_event_forwarding_always_enabled" } + } + } + + val updateOverlays: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorPlugin".cstr.ptr, + "update_overlays".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method update_overlays" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorProperty.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorProperty.kt index f8306516..f302dc5a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorProperty.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorProperty.kt @@ -309,131 +309,167 @@ open class EditorProperty( * Container for method_bind pointers for EditorProperty */ private object __method_bind { - val addFocusable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, - "add_focusable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_focusable" } - } - val emitChanged: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, - "emit_changed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method emit_changed" } - } - val getEditedObject: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, - "get_edited_object".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_edited_object" } - } - val getEditedProperty: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, - "get_edited_property".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_edited_property" } - } - val getLabel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, - "get_label".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_label" } - } - val getTooltipText: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, - "get_tooltip_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tooltip_text" } - } - val isCheckable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, - "is_checkable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_checkable" } - } - val isChecked: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, - "is_checked".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_checked" } - } - val isDrawRed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, - "is_draw_red".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_draw_red" } - } - val isKeying: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, - "is_keying".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_keying" } - } - val isReadOnly: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, - "is_read_only".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_read_only" } - } - val setBottomEditor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, - "set_bottom_editor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bottom_editor" } - } - val setCheckable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, - "set_checkable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_checkable" } - } - val setChecked: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, - "set_checked".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_checked" } - } - val setDrawRed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, - "set_draw_red".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_draw_red" } - } - val setKeying: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, - "set_keying".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_keying" } - } - val setLabel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, - "set_label".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_label" } - } - val setReadOnly: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, - "set_read_only".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_read_only" } - }} + val addFocusable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, + "add_focusable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_focusable" } + } + } + + val emitChanged: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, + "emit_changed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method emit_changed" } + } + } + + val getEditedObject: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, + "get_edited_object".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_edited_object" } + } + } + + val getEditedProperty: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, + "get_edited_property".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_edited_property" } + } + } + + val getLabel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, + "get_label".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_label" } + } + } + + val getTooltipText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, + "get_tooltip_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tooltip_text" } + } + } + + val isCheckable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, + "is_checkable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_checkable" } + } + } + + val isChecked: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, + "is_checked".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_checked" } + } + } + + val isDrawRed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, + "is_draw_red".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_draw_red" } + } + } + + val isKeying: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, + "is_keying".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_keying" } + } + } + + val isReadOnly: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, + "is_read_only".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_read_only" } + } + } + + val setBottomEditor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, + "set_bottom_editor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bottom_editor" } + } + } + + val setCheckable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, + "set_checkable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_checkable" } + } + } + + val setChecked: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, + "set_checked".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_checked" } + } + } + + val setDrawRed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, + "set_draw_red".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_draw_red" } + } + } + + val setKeying: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, + "set_keying".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_keying" } + } + } + + val setLabel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, + "set_label".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_label" } + } + } + + val setReadOnly: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorProperty".cstr.ptr, + "set_read_only".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_read_only" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorResourcePreview.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorResourcePreview.kt index f0f08952..5a8e6bc5 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorResourcePreview.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorResourcePreview.kt @@ -113,40 +113,51 @@ open class EditorResourcePreview( * Container for method_bind pointers for EditorResourcePreview */ private object __method_bind { - val addPreviewGenerator: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorResourcePreview".cstr.ptr, - "add_preview_generator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_preview_generator" } - } - val checkForInvalidation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorResourcePreview".cstr.ptr, - "check_for_invalidation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method check_for_invalidation" } - } - val queueEditedResourcePreview: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorResourcePreview".cstr.ptr, - "queue_edited_resource_preview".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method queue_edited_resource_preview" } - } - val queueResourcePreview: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorResourcePreview".cstr.ptr, - "queue_resource_preview".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method queue_resource_preview" } - } - val removePreviewGenerator: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorResourcePreview".cstr.ptr, - "remove_preview_generator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_preview_generator" } - }} + val addPreviewGenerator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorResourcePreview".cstr.ptr, + "add_preview_generator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_preview_generator" } + } + } + + val checkForInvalidation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorResourcePreview".cstr.ptr, + "check_for_invalidation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method check_for_invalidation" } + } + } + + val queueEditedResourcePreview: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorResourcePreview".cstr.ptr, + "queue_edited_resource_preview".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method queue_edited_resource_preview" + } + } + } + + val queueResourcePreview: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorResourcePreview".cstr.ptr, + "queue_resource_preview".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method queue_resource_preview" } + } + } + + val removePreviewGenerator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorResourcePreview".cstr.ptr, + "remove_preview_generator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_preview_generator" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorSceneImporter.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorSceneImporter.kt index 59ff15fa..4bcc9554 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorSceneImporter.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorSceneImporter.kt @@ -126,20 +126,25 @@ open class EditorSceneImporter( * Container for method_bind pointers for EditorSceneImporter */ private object __method_bind { - val importAnimationFromOtherImporter: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSceneImporter".cstr.ptr, - "import_animation_from_other_importer".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method import_animation_from_other_importer" } - } - val importSceneFromOtherImporter: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSceneImporter".cstr.ptr, - "import_scene_from_other_importer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method import_scene_from_other_importer" } - }} + val importAnimationFromOtherImporter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSceneImporter".cstr.ptr, + "import_animation_from_other_importer".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method import_animation_from_other_importer" } + } + } + + val importSceneFromOtherImporter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSceneImporter".cstr.ptr, + "import_scene_from_other_importer".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method import_scene_from_other_importer" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorScenePostImport.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorScenePostImport.kt index 5f3a90b6..92a72670 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorScenePostImport.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorScenePostImport.kt @@ -67,19 +67,23 @@ open class EditorScenePostImport( * Container for method_bind pointers for EditorScenePostImport */ private object __method_bind { - val getSourceFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorScenePostImport".cstr.ptr, - "get_source_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_source_file" } - } - val getSourceFolder: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorScenePostImport".cstr.ptr, - "get_source_folder".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_source_folder" } - }} + val getSourceFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorScenePostImport".cstr.ptr, + "get_source_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_source_file" } + } + } + + val getSourceFolder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorScenePostImport".cstr.ptr, + "get_source_folder".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_source_folder" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorScript.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorScript.kt index 828caa94..46a995bf 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorScript.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorScript.kt @@ -76,26 +76,32 @@ open class EditorScript( * Container for method_bind pointers for EditorScript */ private object __method_bind { - val addRootNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorScript".cstr.ptr, - "add_root_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_root_node" } - } - val getEditorInterface: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorScript".cstr.ptr, - "get_editor_interface".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_editor_interface" } - } - val getScene: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorScript".cstr.ptr, - "get_scene".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_scene" } - }} + val addRootNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorScript".cstr.ptr, + "add_root_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_root_node" } + } + } + + val getEditorInterface: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorScript".cstr.ptr, + "get_editor_interface".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_editor_interface" } + } + } + + val getScene: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorScript".cstr.ptr, + "get_scene".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_scene" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorSelection.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorSelection.kt index f6d8f505..ca40ee53 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorSelection.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorSelection.kt @@ -97,40 +97,51 @@ open class EditorSelection( * Container for method_bind pointers for EditorSelection */ private object __method_bind { - val addNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSelection".cstr.ptr, - "add_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_node" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSelection".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val getSelectedNodes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSelection".cstr.ptr, - "get_selected_nodes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_selected_nodes" } - } - val getTransformableSelectedNodes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSelection".cstr.ptr, - "get_transformable_selected_nodes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_transformable_selected_nodes" } - } - val removeNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSelection".cstr.ptr, - "remove_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_node" } - }} + val addNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSelection".cstr.ptr, + "add_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_node" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSelection".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val getSelectedNodes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSelection".cstr.ptr, + "get_selected_nodes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_selected_nodes" } + } + } + + val getTransformableSelectedNodes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSelection".cstr.ptr, + "get_transformable_selected_nodes".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_transformable_selected_nodes" } + } + } + + val removeNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSelection".cstr.ptr, + "remove_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_node" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorSettings.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorSettings.kt index 1787f3d5..f9e21c8f 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorSettings.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorSettings.kt @@ -225,117 +225,149 @@ open class EditorSettings( * Container for method_bind pointers for EditorSettings */ private object __method_bind { - val addPropertyInfo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, - "add_property_info".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_property_info" } - } - val erase: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, - "erase".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method erase" } - } - val getFavorites: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, - "get_favorites".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_favorites" } - } - val getProjectMetadata: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, - "get_project_metadata".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_project_metadata" } - } - val getProjectSettingsDir: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, - "get_project_settings_dir".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_project_settings_dir" } - } - val getRecentDirs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, - "get_recent_dirs".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_recent_dirs" } - } - val getSetting: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, - "get_setting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_setting" } - } - val getSettingsDir: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, - "get_settings_dir".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_settings_dir" } - } - val hasSetting: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, - "has_setting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_setting" } - } - val propertyCanRevert: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, - "property_can_revert".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method property_can_revert" } - } - val propertyGetRevert: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, - "property_get_revert".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method property_get_revert" } - } - val setFavorites: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, - "set_favorites".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_favorites" } - } - val setInitialValue: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, - "set_initial_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_initial_value" } - } - val setProjectMetadata: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, - "set_project_metadata".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_project_metadata" } - } - val setRecentDirs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, - "set_recent_dirs".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_recent_dirs" } - } - val setSetting: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, - "set_setting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_setting" } - }} + val addPropertyInfo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, + "add_property_info".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_property_info" } + } + } + + val erase: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, + "erase".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method erase" } + } + } + + val getFavorites: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, + "get_favorites".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_favorites" } + } + } + + val getProjectMetadata: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, + "get_project_metadata".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_project_metadata" } + } + } + + val getProjectSettingsDir: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, + "get_project_settings_dir".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_project_settings_dir" } + } + } + + val getRecentDirs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, + "get_recent_dirs".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_recent_dirs" } + } + } + + val getSetting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, + "get_setting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_setting" } + } + } + + val getSettingsDir: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, + "get_settings_dir".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_settings_dir" } + } + } + + val hasSetting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, + "has_setting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_setting" } + } + } + + val propertyCanRevert: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, + "property_can_revert".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method property_can_revert" } + } + } + + val propertyGetRevert: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, + "property_get_revert".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method property_get_revert" } + } + } + + val setFavorites: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, + "set_favorites".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_favorites" } + } + } + + val setInitialValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, + "set_initial_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_initial_value" } + } + } + + val setProjectMetadata: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, + "set_project_metadata".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_project_metadata" } + } + } + + val setRecentDirs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, + "set_recent_dirs".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_recent_dirs" } + } + } + + val setSetting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSettings".cstr.ptr, + "set_setting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_setting" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorSpatialGizmo.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorSpatialGizmo.kt index 781a9a85..be1577b2 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorSpatialGizmo.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorSpatialGizmo.kt @@ -204,82 +204,104 @@ open class EditorSpatialGizmo( * Container for method_bind pointers for EditorSpatialGizmo */ private object __method_bind { - val addCollisionSegments: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, - "add_collision_segments".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_collision_segments" } - } - val addCollisionTriangles: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, - "add_collision_triangles".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_collision_triangles" } - } - val addHandles: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, - "add_handles".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_handles" } - } - val addLines: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, - "add_lines".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_lines" } - } - val addMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, - "add_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_mesh" } - } - val addUnscaledBillboard: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, - "add_unscaled_billboard".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_unscaled_billboard" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val getPlugin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, - "get_plugin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_plugin" } - } - val getSpatialNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, - "get_spatial_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_spatial_node" } - } - val setHidden: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, - "set_hidden".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_hidden" } - } - val setSpatialNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, - "set_spatial_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_spatial_node" } - }} + val addCollisionSegments: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, + "add_collision_segments".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_collision_segments" } + } + } + + val addCollisionTriangles: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, + "add_collision_triangles".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_collision_triangles" } + } + } + + val addHandles: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, + "add_handles".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_handles" } + } + } + + val addLines: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, + "add_lines".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_lines" } + } + } + + val addMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, + "add_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_mesh" } + } + } + + val addUnscaledBillboard: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, + "add_unscaled_billboard".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_unscaled_billboard" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val getPlugin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, + "get_plugin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_plugin" } + } + } + + val getSpatialNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, + "get_spatial_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_spatial_node" } + } + } + + val setHidden: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, + "set_hidden".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_hidden" } + } + } + + val setSpatialNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmo".cstr.ptr, + "set_spatial_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_spatial_node" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorSpatialGizmoPlugin.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorSpatialGizmoPlugin.kt index 94d87cc6..f8386278 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorSpatialGizmoPlugin.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorSpatialGizmoPlugin.kt @@ -170,40 +170,50 @@ open class EditorSpatialGizmoPlugin( * Container for method_bind pointers for EditorSpatialGizmoPlugin */ private object __method_bind { - val addMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmoPlugin".cstr.ptr, - "add_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_material" } - } - val createHandleMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmoPlugin".cstr.ptr, - "create_handle_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_handle_material" } - } - val createIconMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmoPlugin".cstr.ptr, - "create_icon_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_icon_material" } - } - val createMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmoPlugin".cstr.ptr, - "create_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_material" } - } - val getMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmoPlugin".cstr.ptr, - "get_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_material" } - }} + val addMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmoPlugin".cstr.ptr, + "add_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_material" } + } + } + + val createHandleMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmoPlugin".cstr.ptr, + "create_handle_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_handle_material" } + } + } + + val createIconMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmoPlugin".cstr.ptr, + "create_icon_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_icon_material" } + } + } + + val createMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmoPlugin".cstr.ptr, + "create_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_material" } + } + } + + val getMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpatialGizmoPlugin".cstr.ptr, + "get_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_material" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorSpinSlider.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorSpinSlider.kt index 17214d75..80065697 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorSpinSlider.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorSpinSlider.kt @@ -142,47 +142,59 @@ open class EditorSpinSlider( * Container for method_bind pointers for EditorSpinSlider */ private object __method_bind { - val getLabel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpinSlider".cstr.ptr, - "get_label".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_label" } - } - val isFlat: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpinSlider".cstr.ptr, - "is_flat".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_flat" } - } - val isReadOnly: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpinSlider".cstr.ptr, - "is_read_only".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_read_only" } - } - val setFlat: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpinSlider".cstr.ptr, - "set_flat".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flat" } - } - val setLabel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpinSlider".cstr.ptr, - "set_label".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_label" } - } - val setReadOnly: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpinSlider".cstr.ptr, - "set_read_only".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_read_only" } - }} + val getLabel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpinSlider".cstr.ptr, + "get_label".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_label" } + } + } + + val isFlat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpinSlider".cstr.ptr, + "is_flat".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_flat" } + } + } + + val isReadOnly: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpinSlider".cstr.ptr, + "is_read_only".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_read_only" } + } + } + + val setFlat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpinSlider".cstr.ptr, + "set_flat".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flat" } + } + } + + val setLabel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpinSlider".cstr.ptr, + "set_label".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_label" } + } + } + + val setReadOnly: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorSpinSlider".cstr.ptr, + "set_read_only".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_read_only" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EditorVCSInterface.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EditorVCSInterface.kt index 23f24290..5cba8661 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EditorVCSInterface.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EditorVCSInterface.kt @@ -188,82 +188,104 @@ open class EditorVCSInterface( * Container for method_bind pointers for EditorVCSInterface */ private object __method_bind { - val commit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, - "commit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method commit" } - } - val getFileDiff: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, - "get_file_diff".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_file_diff" } - } - val getModifiedFilesData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, - "get_modified_files_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_modified_files_data" } - } - val getProjectName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, - "get_project_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_project_name" } - } - val getVcsName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, - "get_vcs_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vcs_name" } - } - val initialize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, - "initialize".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method initialize" } - } - val isAddonReady: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, - "is_addon_ready".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_addon_ready" } - } - val isVcsInitialized: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, - "is_vcs_initialized".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_vcs_initialized" } - } - val shutDown: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, - "shut_down".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shut_down" } - } - val stageFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, - "stage_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method stage_file" } - } - val unstageFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, - "unstage_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method unstage_file" } - }} + val commit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, + "commit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method commit" } + } + } + + val getFileDiff: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, + "get_file_diff".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_file_diff" } + } + } + + val getModifiedFilesData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, + "get_modified_files_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_modified_files_data" } + } + } + + val getProjectName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, + "get_project_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_project_name" } + } + } + + val getVcsName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, + "get_vcs_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vcs_name" } + } + } + + val initialize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, + "initialize".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method initialize" } + } + } + + val isAddonReady: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, + "is_addon_ready".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_addon_ready" } + } + } + + val isVcsInitialized: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, + "is_vcs_initialized".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_vcs_initialized" } + } + } + + val shutDown: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, + "shut_down".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shut_down" } + } + } + + val stageFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, + "stage_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method stage_file" } + } + } + + val unstageFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EditorVCSInterface".cstr.ptr, + "unstage_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method unstage_file" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/EncodedObjectAsID.kt b/godot-kotlin/src/nativeGen/kotlin/godot/EncodedObjectAsID.kt index 4814aa58..39cf47e0 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/EncodedObjectAsID.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/EncodedObjectAsID.kt @@ -74,19 +74,23 @@ open class EncodedObjectAsID( * Container for method_bind pointers for EncodedObjectAsID */ private object __method_bind { - val getObjectId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EncodedObjectAsID".cstr.ptr, - "get_object_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_object_id" } - } - val setObjectId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EncodedObjectAsID".cstr.ptr, - "set_object_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_object_id" } - }} + val getObjectId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EncodedObjectAsID".cstr.ptr, + "get_object_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_object_id" } + } + } + + val setObjectId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("EncodedObjectAsID".cstr.ptr, + "set_object_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_object_id" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Engine.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Engine.kt index b3183353..2b368d34 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Engine.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Engine.kt @@ -324,157 +324,232 @@ open class EngineInternal( * Container for method_bind pointers for Engine */ private object __method_bind { - val getAuthorInfo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "get_author_info".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_author_info" } - } - val getCopyrightInfo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "get_copyright_info".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_copyright_info" } - } - val getDonorInfo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "get_donor_info".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_donor_info" } - } - val getFramesDrawn: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "get_frames_drawn".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_frames_drawn" } - } - val getFramesPerSecond: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "get_frames_per_second".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_frames_per_second" } - } - val getIdleFrames: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "get_idle_frames".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_idle_frames" } - } - val getIterationsPerSecond: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "get_iterations_per_second".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_iterations_per_second" } - } - val getLicenseInfo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "get_license_info".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_license_info" } - } - val getLicenseText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "get_license_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_license_text" } - } - val getMainLoop: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "get_main_loop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_main_loop" } - } - val getPhysicsFrames: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "get_physics_frames".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_physics_frames" } - } - val getPhysicsInterpolationFraction: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "get_physics_interpolation_fraction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_physics_interpolation_fraction" + val getAuthorInfo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "get_author_info".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_author_info" } } - } - val getPhysicsJitterFix: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "get_physics_jitter_fix".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_physics_jitter_fix" } - } - val getSingleton: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "get_singleton".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_singleton" } - } - val getTargetFps: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "get_target_fps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_target_fps" } - } - val getTimeScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "get_time_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_time_scale" } - } - val getVersionInfo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "get_version_info".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_version_info" } - } - val hasSingleton: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "has_singleton".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_singleton" } - } - val isEditorHint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "is_editor_hint".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_editor_hint" } - } - val isInPhysicsFrame: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "is_in_physics_frame".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_in_physics_frame" } - } - val setEditorHint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "set_editor_hint".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_editor_hint" } - } - val setIterationsPerSecond: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "set_iterations_per_second".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_iterations_per_second" } - } - val setPhysicsJitterFix: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "set_physics_jitter_fix".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_physics_jitter_fix" } - } - val setTargetFps: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "set_target_fps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_target_fps" } - } - val setTimeScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, - "set_time_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_time_scale" } - }} + } + + val getCopyrightInfo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "get_copyright_info".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_copyright_info" } + } + } + + val getDonorInfo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "get_donor_info".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_donor_info" } + } + } + + val getFramesDrawn: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "get_frames_drawn".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_frames_drawn" } + } + } + + val getFramesPerSecond: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "get_frames_per_second".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_frames_per_second" } + } + } + + val getIdleFrames: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "get_idle_frames".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_idle_frames" } + } + } + + val getIterationsPerSecond: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "get_iterations_per_second".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_iterations_per_second" } + } + } + + val getLicenseInfo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "get_license_info".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_license_info" } + } + } + + val getLicenseText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "get_license_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_license_text" } + } + } + + val getMainLoop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "get_main_loop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_main_loop" } + } + } + + val getPhysicsFrames: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "get_physics_frames".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_physics_frames" } + } + } + + val getPhysicsInterpolationFraction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "get_physics_interpolation_fraction".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_physics_interpolation_fraction" } + } + } + + val getPhysicsJitterFix: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "get_physics_jitter_fix".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_physics_jitter_fix" } + } + } + + val getSingleton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "get_singleton".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_singleton" } + } + } + + val getTargetFps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "get_target_fps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_target_fps" } + } + } + + val getTimeScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "get_time_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_time_scale" } + } + } + + val getVersionInfo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "get_version_info".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_version_info" } + } + } + + val hasSingleton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "has_singleton".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_singleton" } + } + } + + val isEditorHint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "is_editor_hint".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_editor_hint" } + } + } + + val isInPhysicsFrame: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "is_in_physics_frame".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_in_physics_frame" } + } + } + + val setEditorHint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "set_editor_hint".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_editor_hint" } + } + } + + val setIterationsPerSecond: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "set_iterations_per_second".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_iterations_per_second" } + } + } + + val setPhysicsJitterFix: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "set_physics_jitter_fix".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_physics_jitter_fix" } + } + } + + val setTargetFps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "set_target_fps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_target_fps" } + } + } + + val setTimeScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Engine".cstr.ptr, + "set_time_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_time_scale" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Environment.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Environment.kt index 1593e7a9..7ad3363c 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Environment.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Environment.kt @@ -2281,1099 +2281,1422 @@ open class Environment( * Container for method_bind pointers for Environment */ private object __method_bind { - val getAdjustmentBrightness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_adjustment_brightness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_adjustment_brightness" } - } - val getAdjustmentColorCorrection: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_adjustment_color_correction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_adjustment_color_correction" } - } - val getAdjustmentContrast: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_adjustment_contrast".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_adjustment_contrast" } - } - val getAdjustmentSaturation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_adjustment_saturation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_adjustment_saturation" } - } - val getAmbientLightColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_ambient_light_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ambient_light_color" } - } - val getAmbientLightEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_ambient_light_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ambient_light_energy" } - } - val getAmbientLightSkyContribution: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_ambient_light_sky_contribution".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ambient_light_sky_contribution" + val getAdjustmentBrightness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_adjustment_brightness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_adjustment_brightness" } + } + } + + val getAdjustmentColorCorrection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_adjustment_color_correction".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_adjustment_color_correction" } + } + } + + val getAdjustmentContrast: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_adjustment_contrast".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_adjustment_contrast" } + } + } + + val getAdjustmentSaturation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_adjustment_saturation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_adjustment_saturation" } + } + } + + val getAmbientLightColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_ambient_light_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ambient_light_color" } + } + } + + val getAmbientLightEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_ambient_light_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ambient_light_energy" } + } + } + + val getAmbientLightSkyContribution: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_ambient_light_sky_contribution".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_ambient_light_sky_contribution" } + } + } + + val getBackground: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_background".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_background" } + } + } + + val getBgColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_bg_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bg_color" } + } + } + + val getBgEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_bg_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bg_energy" } + } + } + + val getCameraFeedId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_camera_feed_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_camera_feed_id" } + } + } + + val getCanvasMaxLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_canvas_max_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_canvas_max_layer" } + } + } + + val getDofBlurFarAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_dof_blur_far_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_dof_blur_far_amount" } + } + } + + val getDofBlurFarDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_dof_blur_far_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_dof_blur_far_distance" } + } + } + + val getDofBlurFarQuality: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_dof_blur_far_quality".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_dof_blur_far_quality" } + } + } + + val getDofBlurFarTransition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_dof_blur_far_transition".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_dof_blur_far_transition" } + } + } + + val getDofBlurNearAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_dof_blur_near_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_dof_blur_near_amount" } + } + } + + val getDofBlurNearDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_dof_blur_near_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_dof_blur_near_distance" } + } + } + + val getDofBlurNearQuality: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_dof_blur_near_quality".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_dof_blur_near_quality" } + } + } + + val getDofBlurNearTransition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_dof_blur_near_transition".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_dof_blur_near_transition" } + } + } + + val getFogColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_fog_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fog_color" } + } + } + + val getFogDepthBegin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_fog_depth_begin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fog_depth_begin" } + } + } + + val getFogDepthCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_fog_depth_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fog_depth_curve" } + } + } + + val getFogDepthEnd: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_fog_depth_end".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fog_depth_end" } + } + } + + val getFogHeightCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_fog_height_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fog_height_curve" } + } + } + + val getFogHeightMax: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_fog_height_max".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fog_height_max" } + } + } + + val getFogHeightMin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_fog_height_min".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fog_height_min" } + } + } + + val getFogSunAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_fog_sun_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fog_sun_amount" } + } + } + + val getFogSunColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_fog_sun_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fog_sun_color" } + } + } + + val getFogTransmitCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_fog_transmit_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fog_transmit_curve" } + } + } + + val getGlowBlendMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_glow_blend_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_glow_blend_mode" } + } + } + + val getGlowBloom: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_glow_bloom".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_glow_bloom" } + } + } + + val getGlowHdrBleedScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_glow_hdr_bleed_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_glow_hdr_bleed_scale" } + } + } + + val getGlowHdrBleedThreshold: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_glow_hdr_bleed_threshold".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_glow_hdr_bleed_threshold" } + } + } + + val getGlowHdrLuminanceCap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_glow_hdr_luminance_cap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_glow_hdr_luminance_cap" } + } + } + + val getGlowIntensity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_glow_intensity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_glow_intensity" } + } + } + + val getGlowStrength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_glow_strength".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_glow_strength" } + } + } + + val getSky: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_sky".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sky" } + } + } + + val getSkyCustomFov: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_sky_custom_fov".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sky_custom_fov" } + } + } + + val getSkyOrientation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_sky_orientation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sky_orientation" } + } + } + + val getSkyRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_sky_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sky_rotation" } + } + } + + val getSkyRotationDegrees: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_sky_rotation_degrees".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sky_rotation_degrees" } + } + } + + val getSsaoAoChannelAffect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_ssao_ao_channel_affect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ssao_ao_channel_affect" } + } + } + + val getSsaoBias: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_ssao_bias".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ssao_bias" } + } + } + + val getSsaoBlur: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_ssao_blur".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ssao_blur" } + } + } + + val getSsaoColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_ssao_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ssao_color" } + } + } + + val getSsaoDirectLightAffect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_ssao_direct_light_affect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ssao_direct_light_affect" } + } + } + + val getSsaoEdgeSharpness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_ssao_edge_sharpness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ssao_edge_sharpness" } + } + } + + val getSsaoIntensity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_ssao_intensity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ssao_intensity" } + } + } + + val getSsaoIntensity2: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_ssao_intensity2".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ssao_intensity2" } + } + } + + val getSsaoQuality: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_ssao_quality".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ssao_quality" } + } + } + + val getSsaoRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_ssao_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ssao_radius" } + } + } + + val getSsaoRadius2: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_ssao_radius2".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ssao_radius2" } + } + } + + val getSsrDepthTolerance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_ssr_depth_tolerance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ssr_depth_tolerance" } + } + } + + val getSsrFadeIn: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_ssr_fade_in".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ssr_fade_in" } + } + } + + val getSsrFadeOut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_ssr_fade_out".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ssr_fade_out" } + } + } + + val getSsrMaxSteps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_ssr_max_steps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ssr_max_steps" } + } + } + + val getTonemapAutoExposure: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_tonemap_auto_exposure".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tonemap_auto_exposure" } + } + } + + val getTonemapAutoExposureGrey: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_tonemap_auto_exposure_grey".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tonemap_auto_exposure_grey" + } + } + } + + val getTonemapAutoExposureMax: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_tonemap_auto_exposure_max".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tonemap_auto_exposure_max" + } + } + } + + val getTonemapAutoExposureMin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_tonemap_auto_exposure_min".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tonemap_auto_exposure_min" + } + } + } + + val getTonemapAutoExposureSpeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_tonemap_auto_exposure_speed".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_tonemap_auto_exposure_speed" } + } + } + + val getTonemapExposure: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_tonemap_exposure".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tonemap_exposure" } + } + } + + val getTonemapWhite: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_tonemap_white".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tonemap_white" } + } + } + + val getTonemapper: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "get_tonemapper".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tonemapper" } + } + } + + val isAdjustmentEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "is_adjustment_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_adjustment_enabled" } + } + } + + val isDofBlurFarEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "is_dof_blur_far_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_dof_blur_far_enabled" } + } + } + + val isDofBlurNearEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "is_dof_blur_near_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_dof_blur_near_enabled" } + } + } + + val isFogDepthEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "is_fog_depth_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_fog_depth_enabled" } + } + } + + val isFogEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "is_fog_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_fog_enabled" } + } + } + + val isFogHeightEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "is_fog_height_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_fog_height_enabled" } + } + } + + val isFogTransmitEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "is_fog_transmit_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_fog_transmit_enabled" } + } + } + + val isGlowBicubicUpscaleEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "is_glow_bicubic_upscale_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_glow_bicubic_upscale_enabled" } + } + } + + val isGlowEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "is_glow_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_glow_enabled" } + } + } + + val isGlowLevelEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "is_glow_level_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_glow_level_enabled" } + } + } + + val isSsaoEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "is_ssao_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_ssao_enabled" } + } + } + + val isSsrEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "is_ssr_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_ssr_enabled" } + } + } + + val isSsrRough: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "is_ssr_rough".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_ssr_rough" } + } + } + + val setAdjustmentBrightness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_adjustment_brightness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_adjustment_brightness" } + } + } + + val setAdjustmentColorCorrection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_adjustment_color_correction".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_adjustment_color_correction" } + } + } + + val setAdjustmentContrast: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_adjustment_contrast".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_adjustment_contrast" } + } + } + + val setAdjustmentEnable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_adjustment_enable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_adjustment_enable" } + } + } + + val setAdjustmentSaturation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_adjustment_saturation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_adjustment_saturation" } + } + } + + val setAmbientLightColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ambient_light_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ambient_light_color" } + } + } + + val setAmbientLightEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ambient_light_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ambient_light_energy" } + } + } + + val setAmbientLightSkyContribution: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ambient_light_sky_contribution".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_ambient_light_sky_contribution" } + } + } + + val setBackground: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_background".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_background" } + } + } + + val setBgColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_bg_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bg_color" } + } + } + + val setBgEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_bg_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bg_energy" } + } + } + + val setCameraFeedId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_camera_feed_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_camera_feed_id" } + } + } + + val setCanvasMaxLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_canvas_max_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_canvas_max_layer" } + } + } + + val setDofBlurFarAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_dof_blur_far_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_dof_blur_far_amount" } + } + } + + val setDofBlurFarDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_dof_blur_far_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_dof_blur_far_distance" } + } + } + + val setDofBlurFarEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_dof_blur_far_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_dof_blur_far_enabled" } + } + } + + val setDofBlurFarQuality: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_dof_blur_far_quality".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_dof_blur_far_quality" } + } + } + + val setDofBlurFarTransition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_dof_blur_far_transition".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_dof_blur_far_transition" } + } + } + + val setDofBlurNearAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_dof_blur_near_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_dof_blur_near_amount" } + } + } + + val setDofBlurNearDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_dof_blur_near_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_dof_blur_near_distance" } + } + } + + val setDofBlurNearEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_dof_blur_near_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_dof_blur_near_enabled" } + } + } + + val setDofBlurNearQuality: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_dof_blur_near_quality".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_dof_blur_near_quality" } + } + } + + val setDofBlurNearTransition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_dof_blur_near_transition".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_dof_blur_near_transition" } + } + } + + val setFogColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_fog_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fog_color" } + } + } + + val setFogDepthBegin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_fog_depth_begin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fog_depth_begin" } + } + } + + val setFogDepthCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_fog_depth_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fog_depth_curve" } + } + } + + val setFogDepthEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_fog_depth_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fog_depth_enabled" } + } + } + + val setFogDepthEnd: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_fog_depth_end".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fog_depth_end" } + } + } + + val setFogEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_fog_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fog_enabled" } + } + } + + val setFogHeightCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_fog_height_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fog_height_curve" } + } + } + + val setFogHeightEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_fog_height_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fog_height_enabled" } + } + } + + val setFogHeightMax: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_fog_height_max".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fog_height_max" } + } + } + + val setFogHeightMin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_fog_height_min".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fog_height_min" } + } + } + + val setFogSunAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_fog_sun_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fog_sun_amount" } + } + } + + val setFogSunColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_fog_sun_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fog_sun_color" } + } + } + + val setFogTransmitCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_fog_transmit_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fog_transmit_curve" } + } + } + + val setFogTransmitEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_fog_transmit_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fog_transmit_enabled" } + } + } + + val setGlowBicubicUpscale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_glow_bicubic_upscale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_glow_bicubic_upscale" } + } + } + + val setGlowBlendMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_glow_blend_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_glow_blend_mode" } + } + } + + val setGlowBloom: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_glow_bloom".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_glow_bloom" } + } + } + + val setGlowEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_glow_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_glow_enabled" } + } + } + + val setGlowHdrBleedScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_glow_hdr_bleed_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_glow_hdr_bleed_scale" } + } + } + + val setGlowHdrBleedThreshold: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_glow_hdr_bleed_threshold".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_glow_hdr_bleed_threshold" } } - } - val getBackground: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_background".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_background" } - } - val getBgColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_bg_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bg_color" } - } - val getBgEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_bg_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bg_energy" } - } - val getCameraFeedId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_camera_feed_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_camera_feed_id" } - } - val getCanvasMaxLayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_canvas_max_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_canvas_max_layer" } - } - val getDofBlurFarAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_dof_blur_far_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_dof_blur_far_amount" } - } - val getDofBlurFarDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_dof_blur_far_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_dof_blur_far_distance" } - } - val getDofBlurFarQuality: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_dof_blur_far_quality".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_dof_blur_far_quality" } - } - val getDofBlurFarTransition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_dof_blur_far_transition".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_dof_blur_far_transition" } - } - val getDofBlurNearAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_dof_blur_near_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_dof_blur_near_amount" } - } - val getDofBlurNearDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_dof_blur_near_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_dof_blur_near_distance" } - } - val getDofBlurNearQuality: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_dof_blur_near_quality".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_dof_blur_near_quality" } - } - val getDofBlurNearTransition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_dof_blur_near_transition".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_dof_blur_near_transition" } - } - val getFogColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_fog_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fog_color" } - } - val getFogDepthBegin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_fog_depth_begin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fog_depth_begin" } - } - val getFogDepthCurve: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_fog_depth_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fog_depth_curve" } - } - val getFogDepthEnd: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_fog_depth_end".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fog_depth_end" } - } - val getFogHeightCurve: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_fog_height_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fog_height_curve" } - } - val getFogHeightMax: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_fog_height_max".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fog_height_max" } - } - val getFogHeightMin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_fog_height_min".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fog_height_min" } - } - val getFogSunAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_fog_sun_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fog_sun_amount" } - } - val getFogSunColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_fog_sun_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fog_sun_color" } - } - val getFogTransmitCurve: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_fog_transmit_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fog_transmit_curve" } - } - val getGlowBlendMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_glow_blend_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_glow_blend_mode" } - } - val getGlowBloom: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_glow_bloom".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_glow_bloom" } - } - val getGlowHdrBleedScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_glow_hdr_bleed_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_glow_hdr_bleed_scale" } - } - val getGlowHdrBleedThreshold: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_glow_hdr_bleed_threshold".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_glow_hdr_bleed_threshold" } - } - val getGlowHdrLuminanceCap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_glow_hdr_luminance_cap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_glow_hdr_luminance_cap" } - } - val getGlowIntensity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_glow_intensity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_glow_intensity" } - } - val getGlowStrength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_glow_strength".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_glow_strength" } - } - val getSky: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_sky".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sky" } - } - val getSkyCustomFov: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_sky_custom_fov".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sky_custom_fov" } - } - val getSkyOrientation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_sky_orientation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sky_orientation" } - } - val getSkyRotation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_sky_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sky_rotation" } - } - val getSkyRotationDegrees: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_sky_rotation_degrees".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sky_rotation_degrees" } - } - val getSsaoAoChannelAffect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_ssao_ao_channel_affect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ssao_ao_channel_affect" } - } - val getSsaoBias: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_ssao_bias".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ssao_bias" } - } - val getSsaoBlur: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_ssao_blur".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ssao_blur" } - } - val getSsaoColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_ssao_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ssao_color" } - } - val getSsaoDirectLightAffect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_ssao_direct_light_affect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ssao_direct_light_affect" } - } - val getSsaoEdgeSharpness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_ssao_edge_sharpness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ssao_edge_sharpness" } - } - val getSsaoIntensity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_ssao_intensity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ssao_intensity" } - } - val getSsaoIntensity2: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_ssao_intensity2".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ssao_intensity2" } - } - val getSsaoQuality: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_ssao_quality".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ssao_quality" } - } - val getSsaoRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_ssao_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ssao_radius" } - } - val getSsaoRadius2: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_ssao_radius2".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ssao_radius2" } - } - val getSsrDepthTolerance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_ssr_depth_tolerance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ssr_depth_tolerance" } - } - val getSsrFadeIn: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_ssr_fade_in".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ssr_fade_in" } - } - val getSsrFadeOut: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_ssr_fade_out".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ssr_fade_out" } - } - val getSsrMaxSteps: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_ssr_max_steps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ssr_max_steps" } - } - val getTonemapAutoExposure: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_tonemap_auto_exposure".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tonemap_auto_exposure" } - } - val getTonemapAutoExposureGrey: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_tonemap_auto_exposure_grey".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tonemap_auto_exposure_grey" } - } - val getTonemapAutoExposureMax: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_tonemap_auto_exposure_max".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tonemap_auto_exposure_max" } - } - val getTonemapAutoExposureMin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_tonemap_auto_exposure_min".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tonemap_auto_exposure_min" } - } - val getTonemapAutoExposureSpeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_tonemap_auto_exposure_speed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tonemap_auto_exposure_speed" } - } - val getTonemapExposure: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_tonemap_exposure".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tonemap_exposure" } - } - val getTonemapWhite: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_tonemap_white".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tonemap_white" } - } - val getTonemapper: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "get_tonemapper".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tonemapper" } - } - val isAdjustmentEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "is_adjustment_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_adjustment_enabled" } - } - val isDofBlurFarEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "is_dof_blur_far_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_dof_blur_far_enabled" } - } - val isDofBlurNearEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "is_dof_blur_near_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_dof_blur_near_enabled" } - } - val isFogDepthEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "is_fog_depth_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_fog_depth_enabled" } - } - val isFogEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "is_fog_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_fog_enabled" } - } - val isFogHeightEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "is_fog_height_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_fog_height_enabled" } - } - val isFogTransmitEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "is_fog_transmit_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_fog_transmit_enabled" } - } - val isGlowBicubicUpscaleEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "is_glow_bicubic_upscale_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_glow_bicubic_upscale_enabled" } - } - val isGlowEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "is_glow_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_glow_enabled" } - } - val isGlowLevelEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "is_glow_level_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_glow_level_enabled" } - } - val isSsaoEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "is_ssao_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_ssao_enabled" } - } - val isSsrEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "is_ssr_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_ssr_enabled" } - } - val isSsrRough: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "is_ssr_rough".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_ssr_rough" } - } - val setAdjustmentBrightness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_adjustment_brightness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_adjustment_brightness" } - } - val setAdjustmentColorCorrection: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_adjustment_color_correction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_adjustment_color_correction" } - } - val setAdjustmentContrast: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_adjustment_contrast".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_adjustment_contrast" } - } - val setAdjustmentEnable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_adjustment_enable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_adjustment_enable" } - } - val setAdjustmentSaturation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_adjustment_saturation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_adjustment_saturation" } - } - val setAmbientLightColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ambient_light_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ambient_light_color" } - } - val setAmbientLightEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ambient_light_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ambient_light_energy" } - } - val setAmbientLightSkyContribution: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ambient_light_sky_contribution".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ambient_light_sky_contribution" + } + + val setGlowHdrLuminanceCap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_glow_hdr_luminance_cap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_glow_hdr_luminance_cap" } } - } - val setBackground: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_background".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_background" } - } - val setBgColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_bg_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bg_color" } - } - val setBgEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_bg_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bg_energy" } - } - val setCameraFeedId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_camera_feed_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_camera_feed_id" } - } - val setCanvasMaxLayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_canvas_max_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_canvas_max_layer" } - } - val setDofBlurFarAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_dof_blur_far_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_dof_blur_far_amount" } - } - val setDofBlurFarDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_dof_blur_far_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_dof_blur_far_distance" } - } - val setDofBlurFarEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_dof_blur_far_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_dof_blur_far_enabled" } - } - val setDofBlurFarQuality: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_dof_blur_far_quality".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_dof_blur_far_quality" } - } - val setDofBlurFarTransition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_dof_blur_far_transition".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_dof_blur_far_transition" } - } - val setDofBlurNearAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_dof_blur_near_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_dof_blur_near_amount" } - } - val setDofBlurNearDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_dof_blur_near_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_dof_blur_near_distance" } - } - val setDofBlurNearEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_dof_blur_near_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_dof_blur_near_enabled" } - } - val setDofBlurNearQuality: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_dof_blur_near_quality".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_dof_blur_near_quality" } - } - val setDofBlurNearTransition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_dof_blur_near_transition".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_dof_blur_near_transition" } - } - val setFogColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_fog_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fog_color" } - } - val setFogDepthBegin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_fog_depth_begin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fog_depth_begin" } - } - val setFogDepthCurve: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_fog_depth_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fog_depth_curve" } - } - val setFogDepthEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_fog_depth_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fog_depth_enabled" } - } - val setFogDepthEnd: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_fog_depth_end".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fog_depth_end" } - } - val setFogEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_fog_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fog_enabled" } - } - val setFogHeightCurve: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_fog_height_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fog_height_curve" } - } - val setFogHeightEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_fog_height_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fog_height_enabled" } - } - val setFogHeightMax: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_fog_height_max".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fog_height_max" } - } - val setFogHeightMin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_fog_height_min".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fog_height_min" } - } - val setFogSunAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_fog_sun_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fog_sun_amount" } - } - val setFogSunColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_fog_sun_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fog_sun_color" } - } - val setFogTransmitCurve: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_fog_transmit_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fog_transmit_curve" } - } - val setFogTransmitEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_fog_transmit_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fog_transmit_enabled" } - } - val setGlowBicubicUpscale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_glow_bicubic_upscale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_glow_bicubic_upscale" } - } - val setGlowBlendMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_glow_blend_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_glow_blend_mode" } - } - val setGlowBloom: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_glow_bloom".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_glow_bloom" } - } - val setGlowEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_glow_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_glow_enabled" } - } - val setGlowHdrBleedScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_glow_hdr_bleed_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_glow_hdr_bleed_scale" } - } - val setGlowHdrBleedThreshold: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_glow_hdr_bleed_threshold".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_glow_hdr_bleed_threshold" } - } - val setGlowHdrLuminanceCap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_glow_hdr_luminance_cap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_glow_hdr_luminance_cap" } - } - val setGlowIntensity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_glow_intensity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_glow_intensity" } - } - val setGlowLevel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_glow_level".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_glow_level" } - } - val setGlowStrength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_glow_strength".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_glow_strength" } - } - val setSky: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_sky".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sky" } - } - val setSkyCustomFov: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_sky_custom_fov".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sky_custom_fov" } - } - val setSkyOrientation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_sky_orientation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sky_orientation" } - } - val setSkyRotation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_sky_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sky_rotation" } - } - val setSkyRotationDegrees: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_sky_rotation_degrees".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sky_rotation_degrees" } - } - val setSsaoAoChannelAffect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ssao_ao_channel_affect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ssao_ao_channel_affect" } - } - val setSsaoBias: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ssao_bias".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ssao_bias" } - } - val setSsaoBlur: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ssao_blur".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ssao_blur" } - } - val setSsaoColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ssao_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ssao_color" } - } - val setSsaoDirectLightAffect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ssao_direct_light_affect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ssao_direct_light_affect" } - } - val setSsaoEdgeSharpness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ssao_edge_sharpness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ssao_edge_sharpness" } - } - val setSsaoEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ssao_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ssao_enabled" } - } - val setSsaoIntensity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ssao_intensity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ssao_intensity" } - } - val setSsaoIntensity2: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ssao_intensity2".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ssao_intensity2" } - } - val setSsaoQuality: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ssao_quality".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ssao_quality" } - } - val setSsaoRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ssao_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ssao_radius" } - } - val setSsaoRadius2: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ssao_radius2".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ssao_radius2" } - } - val setSsrDepthTolerance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ssr_depth_tolerance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ssr_depth_tolerance" } - } - val setSsrEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ssr_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ssr_enabled" } - } - val setSsrFadeIn: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ssr_fade_in".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ssr_fade_in" } - } - val setSsrFadeOut: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ssr_fade_out".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ssr_fade_out" } - } - val setSsrMaxSteps: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ssr_max_steps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ssr_max_steps" } - } - val setSsrRough: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_ssr_rough".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ssr_rough" } - } - val setTonemapAutoExposure: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_tonemap_auto_exposure".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tonemap_auto_exposure" } - } - val setTonemapAutoExposureGrey: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_tonemap_auto_exposure_grey".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tonemap_auto_exposure_grey" } - } - val setTonemapAutoExposureMax: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_tonemap_auto_exposure_max".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tonemap_auto_exposure_max" } - } - val setTonemapAutoExposureMin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_tonemap_auto_exposure_min".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tonemap_auto_exposure_min" } - } - val setTonemapAutoExposureSpeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_tonemap_auto_exposure_speed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tonemap_auto_exposure_speed" } - } - val setTonemapExposure: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_tonemap_exposure".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tonemap_exposure" } - } - val setTonemapWhite: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_tonemap_white".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tonemap_white" } - } - val setTonemapper: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, - "set_tonemapper".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tonemapper" } - }} + } + + val setGlowIntensity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_glow_intensity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_glow_intensity" } + } + } + + val setGlowLevel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_glow_level".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_glow_level" } + } + } + + val setGlowStrength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_glow_strength".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_glow_strength" } + } + } + + val setSky: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_sky".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sky" } + } + } + + val setSkyCustomFov: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_sky_custom_fov".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sky_custom_fov" } + } + } + + val setSkyOrientation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_sky_orientation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sky_orientation" } + } + } + + val setSkyRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_sky_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sky_rotation" } + } + } + + val setSkyRotationDegrees: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_sky_rotation_degrees".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sky_rotation_degrees" } + } + } + + val setSsaoAoChannelAffect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ssao_ao_channel_affect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ssao_ao_channel_affect" } + } + } + + val setSsaoBias: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ssao_bias".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ssao_bias" } + } + } + + val setSsaoBlur: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ssao_blur".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ssao_blur" } + } + } + + val setSsaoColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ssao_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ssao_color" } + } + } + + val setSsaoDirectLightAffect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ssao_direct_light_affect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ssao_direct_light_affect" } + } + } + + val setSsaoEdgeSharpness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ssao_edge_sharpness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ssao_edge_sharpness" } + } + } + + val setSsaoEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ssao_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ssao_enabled" } + } + } + + val setSsaoIntensity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ssao_intensity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ssao_intensity" } + } + } + + val setSsaoIntensity2: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ssao_intensity2".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ssao_intensity2" } + } + } + + val setSsaoQuality: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ssao_quality".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ssao_quality" } + } + } + + val setSsaoRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ssao_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ssao_radius" } + } + } + + val setSsaoRadius2: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ssao_radius2".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ssao_radius2" } + } + } + + val setSsrDepthTolerance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ssr_depth_tolerance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ssr_depth_tolerance" } + } + } + + val setSsrEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ssr_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ssr_enabled" } + } + } + + val setSsrFadeIn: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ssr_fade_in".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ssr_fade_in" } + } + } + + val setSsrFadeOut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ssr_fade_out".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ssr_fade_out" } + } + } + + val setSsrMaxSteps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ssr_max_steps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ssr_max_steps" } + } + } + + val setSsrRough: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_ssr_rough".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ssr_rough" } + } + } + + val setTonemapAutoExposure: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_tonemap_auto_exposure".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tonemap_auto_exposure" } + } + } + + val setTonemapAutoExposureGrey: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_tonemap_auto_exposure_grey".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tonemap_auto_exposure_grey" + } + } + } + + val setTonemapAutoExposureMax: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_tonemap_auto_exposure_max".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tonemap_auto_exposure_max" + } + } + } + + val setTonemapAutoExposureMin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_tonemap_auto_exposure_min".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tonemap_auto_exposure_min" + } + } + } + + val setTonemapAutoExposureSpeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_tonemap_auto_exposure_speed".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_tonemap_auto_exposure_speed" } + } + } + + val setTonemapExposure: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_tonemap_exposure".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tonemap_exposure" } + } + } + + val setTonemapWhite: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_tonemap_white".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tonemap_white" } + } + } + + val setTonemapper: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Environment".cstr.ptr, + "set_tonemapper".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tonemapper" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Expression.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Expression.kt index 6c7e3998..7b5e50c2 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Expression.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Expression.kt @@ -103,29 +103,41 @@ open class Expression( * Container for method_bind pointers for Expression */ private object __method_bind { - val execute: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Expression".cstr.ptr, - "execute".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method execute" } - } - val getErrorText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Expression".cstr.ptr, - "get_error_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_error_text" } - } - val hasExecuteFailed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Expression".cstr.ptr, - "has_execute_failed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_execute_failed" } - } - val parse: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Expression".cstr.ptr, - "parse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method parse" } - }} + val execute: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Expression".cstr.ptr, + "execute".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method execute" } + } + } + + val getErrorText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Expression".cstr.ptr, + "get_error_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_error_text" } + } + } + + val hasExecuteFailed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Expression".cstr.ptr, + "has_execute_failed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_execute_failed" } + } + } + + val parse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Expression".cstr.ptr, + "parse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method parse" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/File.kt b/godot-kotlin/src/nativeGen/kotlin/godot/File.kt index 1a0601ff..deb848dd 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/File.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/File.kt @@ -559,281 +559,373 @@ open class File( * Container for method_bind pointers for File */ private object __method_bind { - val close: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "close".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method close" } - } - val eofReached: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "eof_reached".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method eof_reached" } - } - val fileExists: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "file_exists".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method file_exists" } - } - val get16: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_16".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_16" } - } - val get32: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_32".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_32" } - } - val get64: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_64".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_64" } - } - val get8: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_8".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_8" } - } - val getAsText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_as_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_as_text" } - } - val getBuffer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_buffer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_buffer" } - } - val getCsvLine: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_csv_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_csv_line" } - } - val getDouble: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_double".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_double" } - } - val getEndianSwap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_endian_swap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_endian_swap" } - } - val getError: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_error".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_error" } - } - val getFloat: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_float".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_float" } - } - val getLen: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_len".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_len" } - } - val getLine: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_line" } - } - val getMd5: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_md5".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_md5" } - } - val getModifiedTime: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_modified_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_modified_time" } - } - val getPascalString: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_pascal_string".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pascal_string" } - } - val getPath: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_path" } - } - val getPathAbsolute: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_path_absolute".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_path_absolute" } - } - val getPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_position" } - } - val getReal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_real".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_real" } - } - val getSha256: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_sha256".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sha256" } - } - val getVar: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "get_var".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_var" } - } - val isOpen: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "is_open".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_open" } - } - val open: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "open".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method open" } - } - val openCompressed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "open_compressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method open_compressed" } - } - val openEncrypted: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "open_encrypted".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method open_encrypted" } - } - val openEncryptedWithPass: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "open_encrypted_with_pass".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method open_encrypted_with_pass" } - } - val seek: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "seek".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method seek" } - } - val seekEnd: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "seek_end".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method seek_end" } - } - val setEndianSwap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "set_endian_swap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_endian_swap" } - } - val store16: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "store_16".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method store_16" } - } - val store32: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "store_32".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method store_32" } - } - val store64: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "store_64".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method store_64" } - } - val store8: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "store_8".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method store_8" } - } - val storeBuffer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "store_buffer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method store_buffer" } - } - val storeCsvLine: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "store_csv_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method store_csv_line" } - } - val storeDouble: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "store_double".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method store_double" } - } - val storeFloat: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "store_float".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method store_float" } - } - val storeLine: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "store_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method store_line" } - } - val storePascalString: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "store_pascal_string".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method store_pascal_string" } - } - val storeReal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "store_real".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method store_real" } - } - val storeString: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "store_string".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method store_string" } - } - val storeVar: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, - "store_var".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method store_var" } - }} + val close: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "close".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method close" } + } + } + + val eofReached: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "eof_reached".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method eof_reached" } + } + } + + val fileExists: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "file_exists".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method file_exists" } + } + } + + val get16: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_16".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_16" } + } + } + + val get32: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_32".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_32" } + } + } + + val get64: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_64".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_64" } + } + } + + val get8: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_8".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_8" } + } + } + + val getAsText: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_as_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_as_text" } + } + } + + val getBuffer: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_buffer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_buffer" } + } + } + + val getCsvLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_csv_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_csv_line" } + } + } + + val getDouble: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_double".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_double" } + } + } + + val getEndianSwap: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_endian_swap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_endian_swap" } + } + } + + val getError: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_error".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_error" } + } + } + + val getFloat: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_float".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_float" } + } + } + + val getLen: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_len".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_len" } + } + } + + val getLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_line" } + } + } + + val getMd5: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_md5".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_md5" } + } + } + + val getModifiedTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_modified_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_modified_time" } + } + } + + val getPascalString: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_pascal_string".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pascal_string" } + } + } + + val getPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_path" } + } + } + + val getPathAbsolute: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_path_absolute".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_path_absolute" } + } + } + + val getPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_position" } + } + } + + val getReal: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_real".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_real" } + } + } + + val getSha256: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_sha256".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sha256" } + } + } + + val getVar: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "get_var".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_var" } + } + } + + val isOpen: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "is_open".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_open" } + } + } + + val open: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "open".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method open" } + } + } + + val openCompressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "open_compressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method open_compressed" } + } + } + + val openEncrypted: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "open_encrypted".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method open_encrypted" } + } + } + + val openEncryptedWithPass: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "open_encrypted_with_pass".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method open_encrypted_with_pass" } + } + } + + val seek: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "seek".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method seek" } + } + } + + val seekEnd: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "seek_end".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method seek_end" } + } + } + + val setEndianSwap: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "set_endian_swap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_endian_swap" } + } + } + + val store16: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "store_16".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method store_16" } + } + } + + val store32: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "store_32".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method store_32" } + } + } + + val store64: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "store_64".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method store_64" } + } + } + + val store8: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "store_8".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method store_8" } + } + } + + val storeBuffer: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "store_buffer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method store_buffer" } + } + } + + val storeCsvLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "store_csv_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method store_csv_line" } + } + } + + val storeDouble: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "store_double".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method store_double" } + } + } + + val storeFloat: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "store_float".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method store_float" } + } + } + + val storeLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "store_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method store_line" } + } + } + + val storePascalString: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "store_pascal_string".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method store_pascal_string" } + } + } + + val storeReal: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "store_real".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method store_real" } + } + } + + val storeString: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "store_string".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method store_string" } + } + } + + val storeVar: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_File".cstr.ptr, + "store_var".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method store_var" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/FileDialog.kt b/godot-kotlin/src/nativeGen/kotlin/godot/FileDialog.kt index 41888652..39f57e8d 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/FileDialog.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/FileDialog.kt @@ -445,137 +445,203 @@ open class FileDialog( * Container for method_bind pointers for FileDialog */ private object __method_bind { - val addFilter: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "add_filter".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_filter" } - } - val clearFilters: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "clear_filters".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_filters" } - } - val deselectItems: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "deselect_items".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method deselect_items" } - } - val getAccess: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "get_access".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_access" } - } - val getCurrentDir: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "get_current_dir".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_dir" } - } - val getCurrentFile: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "get_current_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_file" } - } - val getCurrentPath: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "get_current_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_path" } - } - val getFilters: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "get_filters".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_filters" } - } - val getLineEdit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "get_line_edit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_line_edit" } - } - val getMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "get_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mode" } - } - val getVbox: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "get_vbox".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vbox" } - } - val invalidate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "invalidate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method invalidate" } - } - val isModeOverridingTitle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "is_mode_overriding_title".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_mode_overriding_title" } - } - val isShowingHiddenFiles: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "is_showing_hidden_files".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_showing_hidden_files" } - } - val setAccess: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "set_access".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_access" } - } - val setCurrentDir: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "set_current_dir".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_current_dir" } - } - val setCurrentFile: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "set_current_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_current_file" } - } - val setCurrentPath: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "set_current_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_current_path" } - } - val setFilters: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "set_filters".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_filters" } - } - val setMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "set_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mode" } - } - val setModeOverridesTitle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "set_mode_overrides_title".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mode_overrides_title" } - } - val setShowHiddenFiles: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, - "set_show_hidden_files".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_show_hidden_files" } - }} + val addFilter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "add_filter".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_filter" } + } + } + + val clearFilters: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "clear_filters".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_filters" } + } + } + + val deselectItems: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "deselect_items".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method deselect_items" } + } + } + + val getAccess: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "get_access".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_access" } + } + } + + val getCurrentDir: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "get_current_dir".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_dir" } + } + } + + val getCurrentFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "get_current_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_file" } + } + } + + val getCurrentPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "get_current_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_path" } + } + } + + val getFilters: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "get_filters".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_filters" } + } + } + + val getLineEdit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "get_line_edit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_line_edit" } + } + } + + val getMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "get_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mode" } + } + } + + val getVbox: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "get_vbox".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vbox" } + } + } + + val invalidate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "invalidate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method invalidate" } + } + } + + val isModeOverridingTitle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "is_mode_overriding_title".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_mode_overriding_title" } + } + } + + val isShowingHiddenFiles: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "is_showing_hidden_files".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_showing_hidden_files" } + } + } + + val setAccess: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "set_access".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_access" } + } + } + + val setCurrentDir: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "set_current_dir".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_current_dir" } + } + } + + val setCurrentFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "set_current_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_current_file" } + } + } + + val setCurrentPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "set_current_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_current_path" } + } + } + + val setFilters: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "set_filters".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_filters" } + } + } + + val setMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "set_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mode" } + } + } + + val setModeOverridesTitle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "set_mode_overrides_title".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mode_overrides_title" } + } + } + + val setShowHiddenFiles: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FileDialog".cstr.ptr, + "set_show_hidden_files".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_show_hidden_files" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Font.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Font.kt index 9bf01b1f..7ae77152 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Font.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Font.kt @@ -174,65 +174,85 @@ open class Font( * Container for method_bind pointers for Font */ private object __method_bind { - val draw: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, - "draw".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw" } - } - val drawChar: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, - "draw_char".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_char" } - } - val getAscent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, - "get_ascent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ascent" } - } - val getDescent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, - "get_descent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_descent" } - } - val getHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, - "get_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_height" } - } - val getStringSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, - "get_string_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_string_size" } - } - val getWordwrapStringSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, - "get_wordwrap_string_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_wordwrap_string_size" } - } - val hasOutline: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, - "has_outline".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_outline" } - } - val isDistanceFieldHint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, - "is_distance_field_hint".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_distance_field_hint" } - } - val updateChanges: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, - "update_changes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method update_changes" } - }} + val draw: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, + "draw".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw" } + } + } + + val drawChar: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, + "draw_char".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_char" } + } + } + + val getAscent: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, + "get_ascent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ascent" } + } + } + + val getDescent: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, + "get_descent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_descent" } + } + } + + val getHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, + "get_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_height" } + } + } + + val getStringSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, + "get_string_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_string_size" } + } + } + + val getWordwrapStringSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, + "get_wordwrap_string_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_wordwrap_string_size" } + } + } + + val hasOutline: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, + "has_outline".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_outline" } + } + } + + val isDistanceFieldHint: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, + "is_distance_field_hint".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_distance_field_hint" } + } + } + + val updateChanges: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Font".cstr.ptr, + "update_changes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method update_changes" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/FuncRef.kt b/godot-kotlin/src/nativeGen/kotlin/godot/FuncRef.kt index 090f82fe..322ca504 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/FuncRef.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/FuncRef.kt @@ -91,35 +91,50 @@ open class FuncRef( * Container for method_bind pointers for FuncRef */ private object __method_bind { - val callFunc: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FuncRef".cstr.ptr, - "call_func".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method call_func" } - } - val callFuncv: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FuncRef".cstr.ptr, - "call_funcv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method call_funcv" } - } - val isValid: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FuncRef".cstr.ptr, - "is_valid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_valid" } - } - val setFunction: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FuncRef".cstr.ptr, - "set_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_function" } - } - val setInstance: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FuncRef".cstr.ptr, - "set_instance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_instance" } - }} + val callFunc: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FuncRef".cstr.ptr, + "call_func".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method call_func" } + } + } + + val callFuncv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FuncRef".cstr.ptr, + "call_funcv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method call_funcv" } + } + } + + val isValid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FuncRef".cstr.ptr, + "is_valid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_valid" } + } + } + + val setFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FuncRef".cstr.ptr, + "set_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_function" } + } + } + + val setInstance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("FuncRef".cstr.ptr, + "set_instance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_instance" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/GDNative.kt b/godot-kotlin/src/nativeGen/kotlin/godot/GDNative.kt index 86f7d131..5c30d83b 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/GDNative.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/GDNative.kt @@ -114,35 +114,50 @@ open class GDNative( * Container for method_bind pointers for GDNative */ private object __method_bind { - val callNative: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNative".cstr.ptr, - "call_native".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method call_native" } - } - val getLibrary: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNative".cstr.ptr, - "get_library".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_library" } - } - val initialize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNative".cstr.ptr, - "initialize".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method initialize" } - } - val setLibrary: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNative".cstr.ptr, - "set_library".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_library" } - } - val terminate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNative".cstr.ptr, - "terminate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method terminate" } - }} + val callNative: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNative".cstr.ptr, + "call_native".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method call_native" } + } + } + + val getLibrary: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNative".cstr.ptr, + "get_library".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_library" } + } + } + + val initialize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNative".cstr.ptr, + "initialize".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method initialize" } + } + } + + val setLibrary: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNative".cstr.ptr, + "set_library".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_library" } + } + } + + val terminate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNative".cstr.ptr, + "terminate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method terminate" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/GDNativeLibrary.kt b/godot-kotlin/src/nativeGen/kotlin/godot/GDNativeLibrary.kt index edbff284..938a66ad 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/GDNativeLibrary.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/GDNativeLibrary.kt @@ -200,89 +200,113 @@ open class GDNativeLibrary( * Container for method_bind pointers for GDNativeLibrary */ private object __method_bind { - val getConfigFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, - "get_config_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_config_file" } - } - val getCurrentDependencies: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, - "get_current_dependencies".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_dependencies" } - } - val getCurrentLibraryPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, - "get_current_library_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_library_path" } - } - val getSymbolPrefix: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, - "get_symbol_prefix".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_symbol_prefix" } - } - val isReloadable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, - "is_reloadable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_reloadable" } - } - val isSingleton: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, - "is_singleton".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_singleton" } - } - val setConfigFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, - "set_config_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_config_file" } - } - val setLoadOnce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, - "set_load_once".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_load_once" } - } - val setReloadable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, - "set_reloadable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_reloadable" } - } - val setSingleton: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, - "set_singleton".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_singleton" } - } - val setSymbolPrefix: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, - "set_symbol_prefix".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_symbol_prefix" } - } - val shouldLoadOnce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, - "should_load_once".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method should_load_once" } - }} + val getConfigFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, + "get_config_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_config_file" } + } + } + + val getCurrentDependencies: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, + "get_current_dependencies".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_dependencies" } + } + } + + val getCurrentLibraryPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, + "get_current_library_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_library_path" } + } + } + + val getSymbolPrefix: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, + "get_symbol_prefix".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_symbol_prefix" } + } + } + + val isReloadable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, + "is_reloadable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_reloadable" } + } + } + + val isSingleton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, + "is_singleton".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_singleton" } + } + } + + val setConfigFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, + "set_config_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_config_file" } + } + } + + val setLoadOnce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, + "set_load_once".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_load_once" } + } + } + + val setReloadable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, + "set_reloadable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_reloadable" } + } + } + + val setSingleton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, + "set_singleton".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_singleton" } + } + } + + val setSymbolPrefix: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, + "set_symbol_prefix".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_symbol_prefix" } + } + } + + val shouldLoadOnce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDNativeLibrary".cstr.ptr, + "should_load_once".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method should_load_once" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/GDScript.kt b/godot-kotlin/src/nativeGen/kotlin/godot/GDScript.kt index 419c655b..8516615a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/GDScript.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/GDScript.kt @@ -67,17 +67,23 @@ open class GDScript( * Container for method_bind pointers for GDScript */ private object __method_bind { - val getAsByteCode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDScript".cstr.ptr, - "get_as_byte_code".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_as_byte_code" } - } - val new: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDScript".cstr.ptr, - "new".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method new" } - }} + val getAsByteCode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDScript".cstr.ptr, + "get_as_byte_code".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_as_byte_code" } + } + } + + val new: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDScript".cstr.ptr, + "new".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method new" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/GDScriptFunctionState.kt b/godot-kotlin/src/nativeGen/kotlin/godot/GDScriptFunctionState.kt index c9f82d85..4737b5a4 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/GDScriptFunctionState.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/GDScriptFunctionState.kt @@ -73,19 +73,23 @@ open class GDScriptFunctionState( * Container for method_bind pointers for GDScriptFunctionState */ private object __method_bind { - val isValid: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDScriptFunctionState".cstr.ptr, - "is_valid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_valid" } - } - val resume: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDScriptFunctionState".cstr.ptr, - "resume".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method resume" } - }} + val isValid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDScriptFunctionState".cstr.ptr, + "is_valid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_valid" } + } + } + + val resume: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GDScriptFunctionState".cstr.ptr, + "resume".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method resume" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/GIProbe.kt b/godot-kotlin/src/nativeGen/kotlin/godot/GIProbe.kt index 6287ff55..102a34f5 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/GIProbe.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/GIProbe.kt @@ -356,137 +356,203 @@ open class GIProbe( * Container for method_bind pointers for GIProbe */ private object __method_bind { - val bake: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "bake".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method bake" } - } - val debugBake: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "debug_bake".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method debug_bake" } - } - val getBias: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "get_bias".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bias" } - } - val getDynamicRange: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "get_dynamic_range".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_dynamic_range" } - } - val getEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "get_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_energy" } - } - val getExtents: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "get_extents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_extents" } - } - val getNormalBias: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "get_normal_bias".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_normal_bias" } - } - val getProbeData: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "get_probe_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_probe_data" } - } - val getPropagation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "get_propagation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_propagation" } - } - val getSubdiv: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "get_subdiv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_subdiv" } - } - val isCompressed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "is_compressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_compressed" } - } - val isInterior: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "is_interior".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_interior" } - } - val setBias: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "set_bias".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bias" } - } - val setCompress: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "set_compress".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_compress" } - } - val setDynamicRange: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "set_dynamic_range".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_dynamic_range" } - } - val setEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "set_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_energy" } - } - val setExtents: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "set_extents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_extents" } - } - val setInterior: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "set_interior".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_interior" } - } - val setNormalBias: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "set_normal_bias".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_normal_bias" } - } - val setProbeData: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "set_probe_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_probe_data" } - } - val setPropagation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "set_propagation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_propagation" } - } - val setSubdiv: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, - "set_subdiv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_subdiv" } - }} + val bake: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "bake".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method bake" } + } + } + + val debugBake: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "debug_bake".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method debug_bake" } + } + } + + val getBias: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "get_bias".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bias" } + } + } + + val getDynamicRange: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "get_dynamic_range".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_dynamic_range" } + } + } + + val getEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "get_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_energy" } + } + } + + val getExtents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "get_extents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_extents" } + } + } + + val getNormalBias: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "get_normal_bias".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_normal_bias" } + } + } + + val getProbeData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "get_probe_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_probe_data" } + } + } + + val getPropagation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "get_propagation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_propagation" } + } + } + + val getSubdiv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "get_subdiv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_subdiv" } + } + } + + val isCompressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "is_compressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_compressed" } + } + } + + val isInterior: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "is_interior".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_interior" } + } + } + + val setBias: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "set_bias".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bias" } + } + } + + val setCompress: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "set_compress".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_compress" } + } + } + + val setDynamicRange: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "set_dynamic_range".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_dynamic_range" } + } + } + + val setEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "set_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_energy" } + } + } + + val setExtents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "set_extents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_extents" } + } + } + + val setInterior: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "set_interior".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_interior" } + } + } + + val setNormalBias: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "set_normal_bias".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_normal_bias" } + } + } + + val setProbeData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "set_probe_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_probe_data" } + } + } + + val setPropagation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "set_propagation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_propagation" } + } + } + + val setSubdiv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbe".cstr.ptr, + "set_subdiv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_subdiv" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/GIProbeData.kt b/godot-kotlin/src/nativeGen/kotlin/godot/GIProbeData.kt index 37f39132..233c901f 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/GIProbeData.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/GIProbeData.kt @@ -359,159 +359,203 @@ open class GIProbeData( * Container for method_bind pointers for GIProbeData */ private object __method_bind { - val getBias: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "get_bias".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bias" } - } - val getBounds: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "get_bounds".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bounds" } - } - val getCellSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "get_cell_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cell_size" } - } - val getDynamicData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "get_dynamic_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_dynamic_data" } - } - val getDynamicRange: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "get_dynamic_range".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_dynamic_range" } - } - val getEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "get_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_energy" } - } - val getNormalBias: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "get_normal_bias".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_normal_bias" } - } - val getPropagation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "get_propagation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_propagation" } - } - val getToCellXform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "get_to_cell_xform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_to_cell_xform" } - } - val isCompressed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "is_compressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_compressed" } - } - val isInterior: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "is_interior".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_interior" } - } - val setBias: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "set_bias".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bias" } - } - val setBounds: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "set_bounds".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bounds" } - } - val setCellSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "set_cell_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cell_size" } - } - val setCompress: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "set_compress".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_compress" } - } - val setDynamicData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "set_dynamic_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_dynamic_data" } - } - val setDynamicRange: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "set_dynamic_range".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_dynamic_range" } - } - val setEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "set_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_energy" } - } - val setInterior: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "set_interior".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_interior" } - } - val setNormalBias: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "set_normal_bias".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_normal_bias" } - } - val setPropagation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "set_propagation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_propagation" } - } - val setToCellXform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, - "set_to_cell_xform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_to_cell_xform" } - }} + val getBias: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "get_bias".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bias" } + } + } + + val getBounds: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "get_bounds".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bounds" } + } + } + + val getCellSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "get_cell_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cell_size" } + } + } + + val getDynamicData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "get_dynamic_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_dynamic_data" } + } + } + + val getDynamicRange: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "get_dynamic_range".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_dynamic_range" } + } + } + + val getEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "get_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_energy" } + } + } + + val getNormalBias: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "get_normal_bias".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_normal_bias" } + } + } + + val getPropagation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "get_propagation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_propagation" } + } + } + + val getToCellXform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "get_to_cell_xform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_to_cell_xform" } + } + } + + val isCompressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "is_compressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_compressed" } + } + } + + val isInterior: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "is_interior".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_interior" } + } + } + + val setBias: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "set_bias".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bias" } + } + } + + val setBounds: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "set_bounds".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bounds" } + } + } + + val setCellSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "set_cell_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cell_size" } + } + } + + val setCompress: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "set_compress".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_compress" } + } + } + + val setDynamicData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "set_dynamic_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_dynamic_data" } + } + } + + val setDynamicRange: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "set_dynamic_range".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_dynamic_range" } + } + } + + val setEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "set_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_energy" } + } + } + + val setInterior: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "set_interior".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_interior" } + } + } + + val setNormalBias: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "set_normal_bias".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_normal_bias" } + } + } + + val setPropagation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "set_propagation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_propagation" } + } + } + + val setToCellXform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GIProbeData".cstr.ptr, + "set_to_cell_xform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_to_cell_xform" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Generic6DOFJoint.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Generic6DOFJoint.kt index 3dd56e3a..2495869f 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Generic6DOFJoint.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Generic6DOFJoint.kt @@ -946,103 +946,131 @@ open class Generic6DOFJoint( * Container for method_bind pointers for Generic6DOFJoint */ private object __method_bind { - val getFlagX: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, - "get_flag_x".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_flag_x" } - } - val getFlagY: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, - "get_flag_y".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_flag_y" } - } - val getFlagZ: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, - "get_flag_z".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_flag_z" } - } - val getParamX: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, - "get_param_x".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_param_x" } - } - val getParamY: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, - "get_param_y".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_param_y" } - } - val getParamZ: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, - "get_param_z".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_param_z" } - } - val getPrecision: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, - "get_precision".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_precision" } - } - val setFlagX: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, - "set_flag_x".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flag_x" } - } - val setFlagY: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, - "set_flag_y".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flag_y" } - } - val setFlagZ: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, - "set_flag_z".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flag_z" } - } - val setParamX: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, - "set_param_x".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_param_x" } - } - val setParamY: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, - "set_param_y".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_param_y" } - } - val setParamZ: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, - "set_param_z".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_param_z" } - } - val setPrecision: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, - "set_precision".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_precision" } - }} + val getFlagX: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, + "get_flag_x".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_flag_x" } + } + } + + val getFlagY: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, + "get_flag_y".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_flag_y" } + } + } + + val getFlagZ: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, + "get_flag_z".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_flag_z" } + } + } + + val getParamX: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, + "get_param_x".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_param_x" } + } + } + + val getParamY: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, + "get_param_y".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_param_y" } + } + } + + val getParamZ: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, + "get_param_z".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_param_z" } + } + } + + val getPrecision: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, + "get_precision".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_precision" } + } + } + + val setFlagX: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, + "set_flag_x".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flag_x" } + } + } + + val setFlagY: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, + "set_flag_y".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flag_y" } + } + } + + val setFlagZ: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, + "set_flag_z".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flag_z" } + } + } + + val setParamX: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, + "set_param_x".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_param_x" } + } + } + + val setParamY: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, + "set_param_y".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_param_y" } + } + } + + val setParamZ: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, + "set_param_z".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_param_z" } + } + } + + val setPrecision: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Generic6DOFJoint".cstr.ptr, + "set_precision".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_precision" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Geometry.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Geometry.kt index 1ef88846..bd06c762 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Geometry.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Geometry.kt @@ -642,221 +642,329 @@ open class GeometryInternal( * Container for method_bind pointers for Geometry */ private object __method_bind { - val buildBoxPlanes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "build_box_planes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method build_box_planes" } - } - val buildCapsulePlanes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "build_capsule_planes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method build_capsule_planes" } - } - val buildCylinderPlanes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "build_cylinder_planes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method build_cylinder_planes" } - } - val clipPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "clip_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clip_polygon" } - } - val clipPolygons2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "clip_polygons_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clip_polygons_2d" } - } - val clipPolylineWithPolygon2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "clip_polyline_with_polygon_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clip_polyline_with_polygon_2d" } - } - val convexHull2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "convex_hull_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method convex_hull_2d" } - } - val excludePolygons2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "exclude_polygons_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method exclude_polygons_2d" } - } - val getClosestPointToSegment: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "get_closest_point_to_segment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_closest_point_to_segment" } - } - val getClosestPointToSegment2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "get_closest_point_to_segment_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_closest_point_to_segment_2d" } - } - val getClosestPointToSegmentUncapped: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "get_closest_point_to_segment_uncapped".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method get_closest_point_to_segment_uncapped" } - } - val getClosestPointToSegmentUncapped2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "get_closest_point_to_segment_uncapped_2d".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method get_closest_point_to_segment_uncapped_2d" } - } - val getClosestPointsBetweenSegments: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "get_closest_points_between_segments".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method get_closest_points_between_segments" } - } - val getClosestPointsBetweenSegments2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "get_closest_points_between_segments_2d".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method get_closest_points_between_segments_2d" } - } - val getUv84NormalBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "get_uv84_normal_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_uv84_normal_bit" } - } - val intersectPolygons2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "intersect_polygons_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method intersect_polygons_2d" } - } - val intersectPolylineWithPolygon2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "intersect_polyline_with_polygon_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method intersect_polyline_with_polygon_2d" + val buildBoxPlanes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "build_box_planes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method build_box_planes" } } - } - val isPointInCircle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "is_point_in_circle".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_point_in_circle" } - } - val isPointInPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "is_point_in_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_point_in_polygon" } - } - val isPolygonClockwise: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "is_polygon_clockwise".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_polygon_clockwise" } - } - val lineIntersectsLine2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "line_intersects_line_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method line_intersects_line_2d" } - } - val makeAtlas: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "make_atlas".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method make_atlas" } - } - val mergePolygons2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "merge_polygons_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method merge_polygons_2d" } - } - val offsetPolygon2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "offset_polygon_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method offset_polygon_2d" } - } - val offsetPolyline2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "offset_polyline_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method offset_polyline_2d" } - } - val pointIsInsideTriangle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "point_is_inside_triangle".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method point_is_inside_triangle" } - } - val rayIntersectsTriangle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "ray_intersects_triangle".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method ray_intersects_triangle" } - } - val segmentIntersectsCircle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "segment_intersects_circle".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method segment_intersects_circle" } - } - val segmentIntersectsConvex: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "segment_intersects_convex".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method segment_intersects_convex" } - } - val segmentIntersectsCylinder: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "segment_intersects_cylinder".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method segment_intersects_cylinder" } - } - val segmentIntersectsSegment2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "segment_intersects_segment_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method segment_intersects_segment_2d" } - } - val segmentIntersectsSphere: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "segment_intersects_sphere".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method segment_intersects_sphere" } - } - val segmentIntersectsTriangle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "segment_intersects_triangle".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method segment_intersects_triangle" } - } - val triangulateDelaunay2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "triangulate_delaunay_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method triangulate_delaunay_2d" } - } - val triangulatePolygon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, - "triangulate_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method triangulate_polygon" } - }} + } + + val buildCapsulePlanes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "build_capsule_planes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method build_capsule_planes" } + } + } + + val buildCylinderPlanes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "build_cylinder_planes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method build_cylinder_planes" } + } + } + + val clipPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "clip_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clip_polygon" } + } + } + + val clipPolygons2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "clip_polygons_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clip_polygons_2d" } + } + } + + val clipPolylineWithPolygon2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "clip_polyline_with_polygon_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clip_polyline_with_polygon_2d" + } + } + } + + val convexHull2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "convex_hull_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method convex_hull_2d" } + } + } + + val excludePolygons2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "exclude_polygons_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method exclude_polygons_2d" } + } + } + + val getClosestPointToSegment: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "get_closest_point_to_segment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_closest_point_to_segment" } + } + } + + val getClosestPointToSegment2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "get_closest_point_to_segment_2d".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_closest_point_to_segment_2d" } + } + } + + val getClosestPointToSegmentUncapped: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "get_closest_point_to_segment_uncapped".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_closest_point_to_segment_uncapped" } + } + } + + val getClosestPointToSegmentUncapped2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "get_closest_point_to_segment_uncapped_2d".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_closest_point_to_segment_uncapped_2d" } + } + } + + val getClosestPointsBetweenSegments: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "get_closest_points_between_segments".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_closest_points_between_segments" } + } + } + + val getClosestPointsBetweenSegments2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "get_closest_points_between_segments_2d".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_closest_points_between_segments_2d" } + } + } + + val getUv84NormalBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "get_uv84_normal_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_uv84_normal_bit" } + } + } + + val intersectPolygons2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "intersect_polygons_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method intersect_polygons_2d" } + } + } + + val intersectPolylineWithPolygon2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "intersect_polyline_with_polygon_2d".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method intersect_polyline_with_polygon_2d" } + } + } + + val isPointInCircle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "is_point_in_circle".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_point_in_circle" } + } + } + + val isPointInPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "is_point_in_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_point_in_polygon" } + } + } + + val isPolygonClockwise: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "is_polygon_clockwise".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_polygon_clockwise" } + } + } + + val lineIntersectsLine2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "line_intersects_line_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method line_intersects_line_2d" } + } + } + + val makeAtlas: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "make_atlas".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method make_atlas" } + } + } + + val mergePolygons2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "merge_polygons_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method merge_polygons_2d" } + } + } + + val offsetPolygon2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "offset_polygon_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method offset_polygon_2d" } + } + } + + val offsetPolyline2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "offset_polyline_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method offset_polyline_2d" } + } + } + + val pointIsInsideTriangle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "point_is_inside_triangle".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method point_is_inside_triangle" } + } + } + + val rayIntersectsTriangle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "ray_intersects_triangle".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method ray_intersects_triangle" } + } + } + + val segmentIntersectsCircle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "segment_intersects_circle".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method segment_intersects_circle" } + } + } + + val segmentIntersectsConvex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "segment_intersects_convex".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method segment_intersects_convex" } + } + } + + val segmentIntersectsCylinder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "segment_intersects_cylinder".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method segment_intersects_cylinder" } + } + } + + val segmentIntersectsSegment2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "segment_intersects_segment_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method segment_intersects_segment_2d" + } + } + } + + val segmentIntersectsSphere: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "segment_intersects_sphere".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method segment_intersects_sphere" } + } + } + + val segmentIntersectsTriangle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "segment_intersects_triangle".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method segment_intersects_triangle" } + } + } + + val triangulateDelaunay2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "triangulate_delaunay_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method triangulate_delaunay_2d" } + } + } + + val triangulatePolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Geometry".cstr.ptr, + "triangulate_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method triangulate_polygon" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/GeometryInstance.kt b/godot-kotlin/src/nativeGen/kotlin/godot/GeometryInstance.kt index 1299007c..bd96120b 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/GeometryInstance.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/GeometryInstance.kt @@ -301,124 +301,158 @@ open class GeometryInstance( * Container for method_bind pointers for GeometryInstance */ private object __method_bind { - val getCastShadowsSetting: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, - "get_cast_shadows_setting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cast_shadows_setting" } - } - val getExtraCullMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, - "get_extra_cull_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_extra_cull_margin" } - } - val getFlag: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, - "get_flag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_flag" } - } - val getLodMaxDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, - "get_lod_max_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_lod_max_distance" } - } - val getLodMaxHysteresis: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, - "get_lod_max_hysteresis".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_lod_max_hysteresis" } - } - val getLodMinDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, - "get_lod_min_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_lod_min_distance" } - } - val getLodMinHysteresis: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, - "get_lod_min_hysteresis".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_lod_min_hysteresis" } - } - val getMaterialOverride: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, - "get_material_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_material_override" } - } - val setCastShadowsSetting: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, - "set_cast_shadows_setting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cast_shadows_setting" } - } - val setCustomAabb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, - "set_custom_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_custom_aabb" } - } - val setExtraCullMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, - "set_extra_cull_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_extra_cull_margin" } - } - val setFlag: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, - "set_flag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flag" } - } - val setLodMaxDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, - "set_lod_max_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_lod_max_distance" } - } - val setLodMaxHysteresis: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, - "set_lod_max_hysteresis".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_lod_max_hysteresis" } - } - val setLodMinDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, - "set_lod_min_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_lod_min_distance" } - } - val setLodMinHysteresis: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, - "set_lod_min_hysteresis".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_lod_min_hysteresis" } - } - val setMaterialOverride: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, - "set_material_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_material_override" } - }} + val getCastShadowsSetting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, + "get_cast_shadows_setting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cast_shadows_setting" } + } + } + + val getExtraCullMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, + "get_extra_cull_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_extra_cull_margin" } + } + } + + val getFlag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, + "get_flag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_flag" } + } + } + + val getLodMaxDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, + "get_lod_max_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_lod_max_distance" } + } + } + + val getLodMaxHysteresis: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, + "get_lod_max_hysteresis".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_lod_max_hysteresis" } + } + } + + val getLodMinDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, + "get_lod_min_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_lod_min_distance" } + } + } + + val getLodMinHysteresis: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, + "get_lod_min_hysteresis".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_lod_min_hysteresis" } + } + } + + val getMaterialOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, + "get_material_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_material_override" } + } + } + + val setCastShadowsSetting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, + "set_cast_shadows_setting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cast_shadows_setting" } + } + } + + val setCustomAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, + "set_custom_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_custom_aabb" } + } + } + + val setExtraCullMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, + "set_extra_cull_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_extra_cull_margin" } + } + } + + val setFlag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, + "set_flag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flag" } + } + } + + val setLodMaxDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, + "set_lod_max_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_lod_max_distance" } + } + } + + val setLodMaxHysteresis: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, + "set_lod_max_hysteresis".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_lod_max_hysteresis" } + } + } + + val setLodMinDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, + "set_lod_min_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_lod_min_distance" } + } + } + + val setLodMinHysteresis: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, + "set_lod_min_hysteresis".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_lod_min_hysteresis" } + } + } + + val setMaterialOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GeometryInstance".cstr.ptr, + "set_material_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_material_override" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Gradient.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Gradient.kt index 15aa2107..5fdc4c61 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Gradient.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Gradient.kt @@ -202,77 +202,113 @@ open class Gradient( * Container for method_bind pointers for Gradient */ private object __method_bind { - val addPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, - "add_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_point" } - } - val getColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, - "get_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_color" } - } - val getColors: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, - "get_colors".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_colors" } - } - val getOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, - "get_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_offset" } - } - val getOffsets: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, - "get_offsets".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_offsets" } - } - val getPointCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, - "get_point_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_count" } - } - val interpolate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, - "interpolate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method interpolate" } - } - val removePoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, - "remove_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_point" } - } - val setColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, - "set_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_color" } - } - val setColors: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, - "set_colors".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_colors" } - } - val setOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, - "set_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_offset" } - } - val setOffsets: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, - "set_offsets".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_offsets" } - }} + val addPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, + "add_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_point" } + } + } + + val getColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, + "get_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_color" } + } + } + + val getColors: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, + "get_colors".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_colors" } + } + } + + val getOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, + "get_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_offset" } + } + } + + val getOffsets: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, + "get_offsets".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_offsets" } + } + } + + val getPointCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, + "get_point_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_count" } + } + } + + val interpolate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, + "interpolate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method interpolate" } + } + } + + val removePoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, + "remove_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_point" } + } + } + + val setColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, + "set_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_color" } + } + } + + val setColors: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, + "set_colors".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_colors" } + } + } + + val setOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, + "set_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_offset" } + } + } + + val setOffsets: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Gradient".cstr.ptr, + "set_offsets".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_offsets" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/GradientTexture.kt b/godot-kotlin/src/nativeGen/kotlin/godot/GradientTexture.kt index 96486677..cdc99bbc 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/GradientTexture.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/GradientTexture.kt @@ -95,26 +95,32 @@ open class GradientTexture( * Container for method_bind pointers for GradientTexture */ private object __method_bind { - val getGradient: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GradientTexture".cstr.ptr, - "get_gradient".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gradient" } - } - val setGradient: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GradientTexture".cstr.ptr, - "set_gradient".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_gradient" } - } - val setWidth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GradientTexture".cstr.ptr, - "set_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_width" } - }} + val getGradient: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GradientTexture".cstr.ptr, + "get_gradient".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gradient" } + } + } + + val setGradient: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GradientTexture".cstr.ptr, + "set_gradient".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_gradient" } + } + } + + val setWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GradientTexture".cstr.ptr, + "set_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_width" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/GraphEdit.kt b/godot-kotlin/src/nativeGen/kotlin/godot/GraphEdit.kt index 88a8a143..4e11354d 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/GraphEdit.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/GraphEdit.kt @@ -476,157 +476,234 @@ open class GraphEdit( * Container for method_bind pointers for GraphEdit */ private object __method_bind { - val addValidConnectionType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "add_valid_connection_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_valid_connection_type" } - } - val addValidLeftDisconnectType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "add_valid_left_disconnect_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_valid_left_disconnect_type" } - } - val addValidRightDisconnectType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "add_valid_right_disconnect_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_valid_right_disconnect_type" } - } - val clearConnections: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "clear_connections".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_connections" } - } - val connectNode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "connect_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method connect_node" } - } - val disconnectNode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "disconnect_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method disconnect_node" } - } - val getConnectionList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "get_connection_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connection_list" } - } - val getScrollOfs: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "get_scroll_ofs".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_scroll_ofs" } - } - val getSnap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "get_snap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_snap" } - } - val getZoom: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "get_zoom".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_zoom" } - } - val getZoomHbox: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "get_zoom_hbox".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_zoom_hbox" } - } - val isNodeConnected: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "is_node_connected".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_node_connected" } - } - val isRightDisconnectsEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "is_right_disconnects_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_right_disconnects_enabled" } - } - val isUsingSnap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "is_using_snap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_using_snap" } - } - val isValidConnectionType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "is_valid_connection_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_valid_connection_type" } - } - val removeValidConnectionType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "remove_valid_connection_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_valid_connection_type" } - } - val removeValidLeftDisconnectType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "remove_valid_left_disconnect_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_valid_left_disconnect_type" + val addValidConnectionType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "add_valid_connection_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_valid_connection_type" } } - } - val removeValidRightDisconnectType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "remove_valid_right_disconnect_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_valid_right_disconnect_type" + } + + val addValidLeftDisconnectType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "add_valid_left_disconnect_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_valid_left_disconnect_type" + } } - } - val setConnectionActivity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "set_connection_activity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_connection_activity" } - } - val setRightDisconnects: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "set_right_disconnects".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_right_disconnects" } - } - val setScrollOfs: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "set_scroll_ofs".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_scroll_ofs" } - } - val setSelected: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "set_selected".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_selected" } - } - val setSnap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "set_snap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_snap" } - } - val setUseSnap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "set_use_snap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_snap" } - } - val setZoom: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, - "set_zoom".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_zoom" } - }} + } + + val addValidRightDisconnectType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "add_valid_right_disconnect_type".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method add_valid_right_disconnect_type" } + } + } + + val clearConnections: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "clear_connections".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_connections" } + } + } + + val connectNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "connect_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method connect_node" } + } + } + + val disconnectNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "disconnect_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method disconnect_node" } + } + } + + val getConnectionList: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "get_connection_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connection_list" } + } + } + + val getScrollOfs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "get_scroll_ofs".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_scroll_ofs" } + } + } + + val getSnap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "get_snap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_snap" } + } + } + + val getZoom: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "get_zoom".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_zoom" } + } + } + + val getZoomHbox: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "get_zoom_hbox".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_zoom_hbox" } + } + } + + val isNodeConnected: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "is_node_connected".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_node_connected" } + } + } + + val isRightDisconnectsEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "is_right_disconnects_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_right_disconnects_enabled" } + } + } + + val isUsingSnap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "is_using_snap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_using_snap" } + } + } + + val isValidConnectionType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "is_valid_connection_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_valid_connection_type" } + } + } + + val removeValidConnectionType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "remove_valid_connection_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_valid_connection_type" } + } + } + + val removeValidLeftDisconnectType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "remove_valid_left_disconnect_type".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method remove_valid_left_disconnect_type" } + } + } + + val removeValidRightDisconnectType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "remove_valid_right_disconnect_type".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method remove_valid_right_disconnect_type" } + } + } + + val setConnectionActivity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "set_connection_activity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_connection_activity" } + } + } + + val setRightDisconnects: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "set_right_disconnects".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_right_disconnects" } + } + } + + val setScrollOfs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "set_scroll_ofs".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_scroll_ofs" } + } + } + + val setSelected: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "set_selected".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_selected" } + } + } + + val setSnap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "set_snap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_snap" } + } + } + + val setUseSnap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "set_use_snap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_snap" } + } + } + + val setZoom: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphEdit".cstr.ptr, + "set_zoom".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_zoom" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/GraphNode.kt b/godot-kotlin/src/nativeGen/kotlin/godot/GraphNode.kt index 8f517a38..b1485eb5 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/GraphNode.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/GraphNode.kt @@ -471,191 +471,286 @@ open class GraphNode( * Container for method_bind pointers for GraphNode */ private object __method_bind { - val clearAllSlots: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "clear_all_slots".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_all_slots" } - } - val clearSlot: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "clear_slot".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_slot" } - } - val getConnectionInputColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "get_connection_input_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connection_input_color" } - } - val getConnectionInputCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "get_connection_input_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connection_input_count" } - } - val getConnectionInputPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "get_connection_input_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connection_input_position" } - } - val getConnectionInputType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "get_connection_input_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connection_input_type" } - } - val getConnectionOutputColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "get_connection_output_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connection_output_color" } - } - val getConnectionOutputCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "get_connection_output_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connection_output_count" } - } - val getConnectionOutputPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "get_connection_output_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connection_output_position" } - } - val getConnectionOutputType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "get_connection_output_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connection_output_type" } - } - val getOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "get_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_offset" } - } - val getOverlay: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "get_overlay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_overlay" } - } - val getSlotColorLeft: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "get_slot_color_left".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_slot_color_left" } - } - val getSlotColorRight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "get_slot_color_right".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_slot_color_right" } - } - val getSlotTypeLeft: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "get_slot_type_left".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_slot_type_left" } - } - val getSlotTypeRight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "get_slot_type_right".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_slot_type_right" } - } - val getTitle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "get_title".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_title" } - } - val isCloseButtonVisible: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "is_close_button_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_close_button_visible" } - } - val isComment: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "is_comment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_comment" } - } - val isResizable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "is_resizable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_resizable" } - } - val isSelected: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "is_selected".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_selected" } - } - val isSlotEnabledLeft: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "is_slot_enabled_left".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_slot_enabled_left" } - } - val isSlotEnabledRight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "is_slot_enabled_right".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_slot_enabled_right" } - } - val setComment: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "set_comment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_comment" } - } - val setOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "set_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_offset" } - } - val setOverlay: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "set_overlay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_overlay" } - } - val setResizable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "set_resizable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_resizable" } - } - val setSelected: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "set_selected".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_selected" } - } - val setShowCloseButton: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "set_show_close_button".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_show_close_button" } - } - val setSlot: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "set_slot".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_slot" } - } - val setTitle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, - "set_title".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_title" } - }} + val clearAllSlots: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "clear_all_slots".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_all_slots" } + } + } + + val clearSlot: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "clear_slot".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_slot" } + } + } + + val getConnectionInputColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "get_connection_input_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connection_input_color" } + } + } + + val getConnectionInputCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "get_connection_input_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connection_input_count" } + } + } + + val getConnectionInputPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "get_connection_input_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connection_input_position" + } + } + } + + val getConnectionInputType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "get_connection_input_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connection_input_type" } + } + } + + val getConnectionOutputColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "get_connection_output_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connection_output_color" } + } + } + + val getConnectionOutputCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "get_connection_output_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connection_output_count" } + } + } + + val getConnectionOutputPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "get_connection_output_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connection_output_position" + } + } + } + + val getConnectionOutputType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "get_connection_output_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connection_output_type" } + } + } + + val getOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "get_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_offset" } + } + } + + val getOverlay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "get_overlay".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_overlay" } + } + } + + val getSlotColorLeft: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "get_slot_color_left".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_slot_color_left" } + } + } + + val getSlotColorRight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "get_slot_color_right".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_slot_color_right" } + } + } + + val getSlotTypeLeft: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "get_slot_type_left".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_slot_type_left" } + } + } + + val getSlotTypeRight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "get_slot_type_right".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_slot_type_right" } + } + } + + val getTitle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "get_title".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_title" } + } + } + + val isCloseButtonVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "is_close_button_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_close_button_visible" } + } + } + + val isComment: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "is_comment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_comment" } + } + } + + val isResizable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "is_resizable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_resizable" } + } + } + + val isSelected: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "is_selected".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_selected" } + } + } + + val isSlotEnabledLeft: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "is_slot_enabled_left".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_slot_enabled_left" } + } + } + + val isSlotEnabledRight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "is_slot_enabled_right".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_slot_enabled_right" } + } + } + + val setComment: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "set_comment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_comment" } + } + } + + val setOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "set_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_offset" } + } + } + + val setOverlay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "set_overlay".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_overlay" } + } + } + + val setResizable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "set_resizable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_resizable" } + } + } + + val setSelected: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "set_selected".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_selected" } + } + } + + val setShowCloseButton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "set_show_close_button".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_show_close_button" } + } + } + + val setSlot: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "set_slot".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_slot" } + } + } + + val setTitle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GraphNode".cstr.ptr, + "set_title".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_title" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/GridContainer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/GridContainer.kt index 123598ff..fdf4adfc 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/GridContainer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/GridContainer.kt @@ -73,19 +73,23 @@ open class GridContainer( * Container for method_bind pointers for GridContainer */ private object __method_bind { - val getColumns: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridContainer".cstr.ptr, - "get_columns".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_columns" } - } - val setColumns: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridContainer".cstr.ptr, - "set_columns".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_columns" } - }} + val getColumns: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridContainer".cstr.ptr, + "get_columns".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_columns" } + } + } + + val setColumns: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridContainer".cstr.ptr, + "set_columns".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_columns" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/GridMap.kt b/godot-kotlin/src/nativeGen/kotlin/godot/GridMap.kt index dce2ff67..647f64da 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/GridMap.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/GridMap.kt @@ -518,221 +518,329 @@ open class GridMap( * Container for method_bind pointers for GridMap */ private object __method_bind { - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val clearBakedMeshes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "clear_baked_meshes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_baked_meshes" } - } - val getBakeMeshInstance: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "get_bake_mesh_instance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bake_mesh_instance" } - } - val getBakeMeshes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "get_bake_meshes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bake_meshes" } - } - val getCellItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "get_cell_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cell_item" } - } - val getCellItemOrientation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "get_cell_item_orientation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cell_item_orientation" } - } - val getCellScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "get_cell_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cell_scale" } - } - val getCellSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "get_cell_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cell_size" } - } - val getCenterX: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "get_center_x".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_center_x" } - } - val getCenterY: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "get_center_y".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_center_y" } - } - val getCenterZ: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "get_center_z".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_center_z" } - } - val getCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "get_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_layer" } - } - val getCollisionLayerBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "get_collision_layer_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_layer_bit" } - } - val getCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "get_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } - } - val getCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "get_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } - } - val getMeshLibrary: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "get_mesh_library".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mesh_library" } - } - val getMeshes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "get_meshes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_meshes" } - } - val getOctantSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "get_octant_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_octant_size" } - } - val getUsedCells: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "get_used_cells".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_used_cells" } - } - val makeBakedMeshes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "make_baked_meshes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method make_baked_meshes" } - } - val mapToWorld: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "map_to_world".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method map_to_world" } - } - val resourceChanged: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "resource_changed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method resource_changed" } - } - val setCellItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "set_cell_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cell_item" } - } - val setCellScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "set_cell_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cell_scale" } - } - val setCellSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "set_cell_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cell_size" } - } - val setCenterX: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "set_center_x".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_center_x" } - } - val setCenterY: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "set_center_y".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_center_y" } - } - val setCenterZ: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "set_center_z".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_center_z" } - } - val setClip: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "set_clip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_clip" } - } - val setCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "set_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_layer" } - } - val setCollisionLayerBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "set_collision_layer_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_layer_bit" } - } - val setCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "set_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } - } - val setCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "set_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } - } - val setMeshLibrary: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "set_mesh_library".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mesh_library" } - } - val setOctantSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "set_octant_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_octant_size" } - } - val worldToMap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, - "world_to_map".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method world_to_map" } - }} + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val clearBakedMeshes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "clear_baked_meshes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_baked_meshes" } + } + } + + val getBakeMeshInstance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "get_bake_mesh_instance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bake_mesh_instance" } + } + } + + val getBakeMeshes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "get_bake_meshes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bake_meshes" } + } + } + + val getCellItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "get_cell_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cell_item" } + } + } + + val getCellItemOrientation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "get_cell_item_orientation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cell_item_orientation" } + } + } + + val getCellScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "get_cell_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cell_scale" } + } + } + + val getCellSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "get_cell_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cell_size" } + } + } + + val getCenterX: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "get_center_x".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_center_x" } + } + } + + val getCenterY: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "get_center_y".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_center_y" } + } + } + + val getCenterZ: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "get_center_z".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_center_z" } + } + } + + val getCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "get_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_layer" } + } + } + + val getCollisionLayerBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "get_collision_layer_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_layer_bit" } + } + } + + val getCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "get_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } + } + } + + val getCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "get_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } + } + } + + val getMeshLibrary: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "get_mesh_library".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mesh_library" } + } + } + + val getMeshes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "get_meshes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_meshes" } + } + } + + val getOctantSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "get_octant_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_octant_size" } + } + } + + val getUsedCells: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "get_used_cells".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_used_cells" } + } + } + + val makeBakedMeshes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "make_baked_meshes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method make_baked_meshes" } + } + } + + val mapToWorld: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "map_to_world".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method map_to_world" } + } + } + + val resourceChanged: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "resource_changed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method resource_changed" } + } + } + + val setCellItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "set_cell_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cell_item" } + } + } + + val setCellScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "set_cell_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cell_scale" } + } + } + + val setCellSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "set_cell_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cell_size" } + } + } + + val setCenterX: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "set_center_x".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_center_x" } + } + } + + val setCenterY: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "set_center_y".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_center_y" } + } + } + + val setCenterZ: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "set_center_z".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_center_z" } + } + } + + val setClip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "set_clip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_clip" } + } + } + + val setCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "set_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_layer" } + } + } + + val setCollisionLayerBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "set_collision_layer_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_layer_bit" } + } + } + + val setCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "set_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } + } + } + + val setCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "set_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } + } + } + + val setMeshLibrary: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "set_mesh_library".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mesh_library" } + } + } + + val setOctantSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "set_octant_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_octant_size" } + } + } + + val worldToMap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GridMap".cstr.ptr, + "world_to_map".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method world_to_map" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/GrooveJoint2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/GrooveJoint2D.kt index ba469af2..82ef9e76 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/GrooveJoint2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/GrooveJoint2D.kt @@ -98,33 +98,41 @@ open class GrooveJoint2D( * Container for method_bind pointers for GrooveJoint2D */ private object __method_bind { - val getInitialOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GrooveJoint2D".cstr.ptr, - "get_initial_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_initial_offset" } - } - val getLength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GrooveJoint2D".cstr.ptr, - "get_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_length" } - } - val setInitialOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GrooveJoint2D".cstr.ptr, - "set_initial_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_initial_offset" } - } - val setLength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GrooveJoint2D".cstr.ptr, - "set_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_length" } - }} + val getInitialOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GrooveJoint2D".cstr.ptr, + "get_initial_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_initial_offset" } + } + } + + val getLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GrooveJoint2D".cstr.ptr, + "get_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_length" } + } + } + + val setInitialOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GrooveJoint2D".cstr.ptr, + "set_initial_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_initial_offset" } + } + } + + val setLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("GrooveJoint2D".cstr.ptr, + "set_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_length" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/HTTPClient.kt b/godot-kotlin/src/nativeGen/kotlin/godot/HTTPClient.kt index 690b9963..7cee84b9 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/HTTPClient.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/HTTPClient.kt @@ -508,126 +508,186 @@ open class HTTPClient( * Container for method_bind pointers for HTTPClient */ private object __method_bind { - val close: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "close".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method close" } - } - val connectToHost: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "connect_to_host".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method connect_to_host" } - } - val getConnection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "get_connection".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connection" } - } - val getReadChunkSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "get_read_chunk_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_read_chunk_size" } - } - val getResponseBodyLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "get_response_body_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_response_body_length" } - } - val getResponseCode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "get_response_code".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_response_code" } - } - val getResponseHeaders: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "get_response_headers".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_response_headers" } - } - val getResponseHeadersAsDictionary: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "get_response_headers_as_dictionary".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_response_headers_as_dictionary" + val close: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "close".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method close" } } - } - val getStatus: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "get_status".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_status" } - } - val hasResponse: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "has_response".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_response" } - } - val isBlockingModeEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "is_blocking_mode_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_blocking_mode_enabled" } - } - val isResponseChunked: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "is_response_chunked".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_response_chunked" } - } - val poll: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "poll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method poll" } - } - val queryStringFromDict: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "query_string_from_dict".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method query_string_from_dict" } - } - val readResponseBodyChunk: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "read_response_body_chunk".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method read_response_body_chunk" } - } - val request: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "request".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method request" } - } - val requestRaw: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "request_raw".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method request_raw" } - } - val setBlockingMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "set_blocking_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_blocking_mode" } - } - val setConnection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "set_connection".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_connection" } - } - val setReadChunkSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, - "set_read_chunk_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_read_chunk_size" } - }} + } + + val connectToHost: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "connect_to_host".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method connect_to_host" } + } + } + + val getConnection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "get_connection".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connection" } + } + } + + val getReadChunkSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "get_read_chunk_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_read_chunk_size" } + } + } + + val getResponseBodyLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "get_response_body_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_response_body_length" } + } + } + + val getResponseCode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "get_response_code".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_response_code" } + } + } + + val getResponseHeaders: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "get_response_headers".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_response_headers" } + } + } + + val getResponseHeadersAsDictionary: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "get_response_headers_as_dictionary".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_response_headers_as_dictionary" } + } + } + + val getStatus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "get_status".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_status" } + } + } + + val hasResponse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "has_response".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_response" } + } + } + + val isBlockingModeEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "is_blocking_mode_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_blocking_mode_enabled" } + } + } + + val isResponseChunked: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "is_response_chunked".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_response_chunked" } + } + } + + val poll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "poll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method poll" } + } + } + + val queryStringFromDict: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "query_string_from_dict".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method query_string_from_dict" } + } + } + + val readResponseBodyChunk: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "read_response_body_chunk".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method read_response_body_chunk" } + } + } + + val request: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "request".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method request" } + } + } + + val requestRaw: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "request_raw".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method request_raw" } + } + } + + val setBlockingMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "set_blocking_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_blocking_mode" } + } + } + + val setConnection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "set_connection".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_connection" } + } + } + + val setReadChunkSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPClient".cstr.ptr, + "set_read_chunk_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_read_chunk_size" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/HTTPRequest.kt b/godot-kotlin/src/nativeGen/kotlin/godot/HTTPRequest.kt index 2e3d1d0d..ad73855c 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/HTTPRequest.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/HTTPRequest.kt @@ -326,124 +326,158 @@ open class HTTPRequest( * Container for method_bind pointers for HTTPRequest */ private object __method_bind { - val cancelRequest: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, - "cancel_request".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cancel_request" } - } - val getBodySize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, - "get_body_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_body_size" } - } - val getBodySizeLimit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, - "get_body_size_limit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_body_size_limit" } - } - val getDownloadChunkSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, - "get_download_chunk_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_download_chunk_size" } - } - val getDownloadFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, - "get_download_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_download_file" } - } - val getDownloadedBytes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, - "get_downloaded_bytes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_downloaded_bytes" } - } - val getHttpClientStatus: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, - "get_http_client_status".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_http_client_status" } - } - val getMaxRedirects: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, - "get_max_redirects".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_max_redirects" } - } - val getTimeout: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, - "get_timeout".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_timeout" } - } - val isUsingThreads: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, - "is_using_threads".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_using_threads" } - } - val request: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, - "request".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method request" } - } - val setBodySizeLimit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, - "set_body_size_limit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_body_size_limit" } - } - val setDownloadChunkSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, - "set_download_chunk_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_download_chunk_size" } - } - val setDownloadFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, - "set_download_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_download_file" } - } - val setMaxRedirects: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, - "set_max_redirects".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_max_redirects" } - } - val setTimeout: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, - "set_timeout".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_timeout" } - } - val setUseThreads: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, - "set_use_threads".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_threads" } - }} + val cancelRequest: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, + "cancel_request".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cancel_request" } + } + } + + val getBodySize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, + "get_body_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_body_size" } + } + } + + val getBodySizeLimit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, + "get_body_size_limit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_body_size_limit" } + } + } + + val getDownloadChunkSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, + "get_download_chunk_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_download_chunk_size" } + } + } + + val getDownloadFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, + "get_download_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_download_file" } + } + } + + val getDownloadedBytes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, + "get_downloaded_bytes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_downloaded_bytes" } + } + } + + val getHttpClientStatus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, + "get_http_client_status".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_http_client_status" } + } + } + + val getMaxRedirects: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, + "get_max_redirects".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_max_redirects" } + } + } + + val getTimeout: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, + "get_timeout".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_timeout" } + } + } + + val isUsingThreads: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, + "is_using_threads".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_using_threads" } + } + } + + val request: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, + "request".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method request" } + } + } + + val setBodySizeLimit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, + "set_body_size_limit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_body_size_limit" } + } + } + + val setDownloadChunkSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, + "set_download_chunk_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_download_chunk_size" } + } + } + + val setDownloadFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, + "set_download_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_download_file" } + } + } + + val setMaxRedirects: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, + "set_max_redirects".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_max_redirects" } + } + } + + val setTimeout: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, + "set_timeout".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_timeout" } + } + } + + val setUseThreads: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HTTPRequest".cstr.ptr, + "set_use_threads".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_threads" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/HashingContext.kt b/godot-kotlin/src/nativeGen/kotlin/godot/HashingContext.kt index 83eb7625..2b915a77 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/HashingContext.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/HashingContext.kt @@ -103,26 +103,32 @@ open class HashingContext( * Container for method_bind pointers for HashingContext */ private object __method_bind { - val finish: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HashingContext".cstr.ptr, - "finish".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method finish" } - } - val start: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HashingContext".cstr.ptr, - "start".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method start" } - } - val update: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HashingContext".cstr.ptr, - "update".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method update" } - }} + val finish: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HashingContext".cstr.ptr, + "finish".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method finish" } + } + } + + val start: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HashingContext".cstr.ptr, + "start".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method start" } + } + } + + val update: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HashingContext".cstr.ptr, + "update".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method update" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/HeightMapShape.kt b/godot-kotlin/src/nativeGen/kotlin/godot/HeightMapShape.kt index 83fef553..dfe32e5e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/HeightMapShape.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/HeightMapShape.kt @@ -136,47 +136,59 @@ open class HeightMapShape( * Container for method_bind pointers for HeightMapShape */ private object __method_bind { - val getMapData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HeightMapShape".cstr.ptr, - "get_map_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_map_data" } - } - val getMapDepth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HeightMapShape".cstr.ptr, - "get_map_depth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_map_depth" } - } - val getMapWidth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HeightMapShape".cstr.ptr, - "get_map_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_map_width" } - } - val setMapData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HeightMapShape".cstr.ptr, - "set_map_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_map_data" } - } - val setMapDepth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HeightMapShape".cstr.ptr, - "set_map_depth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_map_depth" } - } - val setMapWidth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HeightMapShape".cstr.ptr, - "set_map_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_map_width" } - }} + val getMapData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HeightMapShape".cstr.ptr, + "get_map_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_map_data" } + } + } + + val getMapDepth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HeightMapShape".cstr.ptr, + "get_map_depth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_map_depth" } + } + } + + val getMapWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HeightMapShape".cstr.ptr, + "get_map_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_map_width" } + } + } + + val setMapData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HeightMapShape".cstr.ptr, + "set_map_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_map_data" } + } + } + + val setMapDepth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HeightMapShape".cstr.ptr, + "set_map_depth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_map_depth" } + } + } + + val setMapWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HeightMapShape".cstr.ptr, + "set_map_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_map_width" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/HingeJoint.kt b/godot-kotlin/src/nativeGen/kotlin/godot/HingeJoint.kt index ecb992db..0b92ad11 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/HingeJoint.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/HingeJoint.kt @@ -224,29 +224,41 @@ open class HingeJoint( * Container for method_bind pointers for HingeJoint */ private object __method_bind { - val getFlag: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HingeJoint".cstr.ptr, - "get_flag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_flag" } - } - val getParam: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HingeJoint".cstr.ptr, - "get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_param" } - } - val setFlag: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HingeJoint".cstr.ptr, - "set_flag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flag" } - } - val setParam: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HingeJoint".cstr.ptr, - "set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_param" } - }} + val getFlag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HingeJoint".cstr.ptr, + "get_flag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_flag" } + } + } + + val getParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HingeJoint".cstr.ptr, + "get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_param" } + } + } + + val setFlag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HingeJoint".cstr.ptr, + "set_flag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flag" } + } + } + + val setParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("HingeJoint".cstr.ptr, + "set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_param" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/IP.kt b/godot-kotlin/src/nativeGen/kotlin/godot/IP.kt index d283255c..6e6a2899 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/IP.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/IP.kt @@ -124,54 +124,70 @@ open class IPInternal( * Container for method_bind pointers for IP */ private object __method_bind { - val clearCache: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("IP".cstr.ptr, - "clear_cache".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_cache" } - } - val eraseResolveItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("IP".cstr.ptr, - "erase_resolve_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method erase_resolve_item" } - } - val getLocalAddresses: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("IP".cstr.ptr, - "get_local_addresses".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_local_addresses" } - } - val getLocalInterfaces: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("IP".cstr.ptr, - "get_local_interfaces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_local_interfaces" } - } - val getResolveItemAddress: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("IP".cstr.ptr, - "get_resolve_item_address".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_resolve_item_address" } - } - val getResolveItemStatus: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("IP".cstr.ptr, - "get_resolve_item_status".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_resolve_item_status" } - } - val resolveHostname: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("IP".cstr.ptr, - "resolve_hostname".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method resolve_hostname" } - } - val resolveHostnameQueueItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("IP".cstr.ptr, - "resolve_hostname_queue_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method resolve_hostname_queue_item" } - }} + val clearCache: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("IP".cstr.ptr, + "clear_cache".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_cache" } + } + } + + val eraseResolveItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("IP".cstr.ptr, + "erase_resolve_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method erase_resolve_item" } + } + } + + val getLocalAddresses: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("IP".cstr.ptr, + "get_local_addresses".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_local_addresses" } + } + } + + val getLocalInterfaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("IP".cstr.ptr, + "get_local_interfaces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_local_interfaces" } + } + } + + val getResolveItemAddress: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("IP".cstr.ptr, + "get_resolve_item_address".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_resolve_item_address" } + } + } + + val getResolveItemStatus: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("IP".cstr.ptr, + "get_resolve_item_status".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_resolve_item_status" } + } + } + + val resolveHostname: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("IP".cstr.ptr, + "resolve_hostname".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method resolve_hostname" } + } + } + + val resolveHostnameQueueItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("IP".cstr.ptr, + "resolve_hostname_queue_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method resolve_hostname_queue_item" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Image.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Image.kt index f83cf27b..75aa7f60 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Image.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Image.kt @@ -786,311 +786,413 @@ open class Image( * Container for method_bind pointers for Image */ private object __method_bind { - val blendRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "blend_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method blend_rect" } - } - val blendRectMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "blend_rect_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method blend_rect_mask" } - } - val blitRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "blit_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method blit_rect" } - } - val blitRectMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "blit_rect_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method blit_rect_mask" } - } - val bumpmapToNormalmap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "bumpmap_to_normalmap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method bumpmap_to_normalmap" } - } - val clearMipmaps: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "clear_mipmaps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_mipmaps" } - } - val compress: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "compress".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method compress" } - } - val convert: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "convert".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method convert" } - } - val copyFrom: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "copy_from".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method copy_from" } - } - val create: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create" } - } - val createFromData: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "create_from_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_from_data" } - } - val crop: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "crop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method crop" } - } - val decompress: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "decompress".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method decompress" } - } - val detectAlpha: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "detect_alpha".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method detect_alpha" } - } - val expandX2Hq2x: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "expand_x2_hq2x".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method expand_x2_hq2x" } - } - val fill: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "fill".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method fill" } - } - val fixAlphaEdges: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "fix_alpha_edges".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method fix_alpha_edges" } - } - val flipX: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "flip_x".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method flip_x" } - } - val flipY: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "flip_y".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method flip_y" } - } - val generateMipmaps: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "generate_mipmaps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method generate_mipmaps" } - } - val getData: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "get_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_data" } - } - val getFormat: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "get_format".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_format" } - } - val getHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "get_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_height" } - } - val getMipmapOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "get_mipmap_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mipmap_offset" } - } - val getPixel: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "get_pixel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pixel" } - } - val getPixelv: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "get_pixelv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pixelv" } - } - val getRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "get_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rect" } - } - val getSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "get_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_size" } - } - val getUsedRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "get_used_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_used_rect" } - } - val getWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "get_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_width" } - } - val hasMipmaps: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "has_mipmaps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_mipmaps" } - } - val isCompressed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "is_compressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_compressed" } - } - val isEmpty: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "is_empty".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_empty" } - } - val isInvisible: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "is_invisible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_invisible" } - } - val load: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "load".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method load" } - } - val loadJpgFromBuffer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "load_jpg_from_buffer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method load_jpg_from_buffer" } - } - val loadPngFromBuffer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "load_png_from_buffer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method load_png_from_buffer" } - } - val loadWebpFromBuffer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "load_webp_from_buffer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method load_webp_from_buffer" } - } - val lock: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "lock".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method lock" } - } - val normalmapToXy: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "normalmap_to_xy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method normalmap_to_xy" } - } - val premultiplyAlpha: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "premultiply_alpha".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method premultiply_alpha" } - } - val resize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "resize".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method resize" } - } - val resizeToPo2: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "resize_to_po2".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method resize_to_po2" } - } - val rgbeToSrgb: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "rgbe_to_srgb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rgbe_to_srgb" } - } - val saveExr: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "save_exr".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method save_exr" } - } - val savePng: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "save_png".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method save_png" } - } - val setPixel: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "set_pixel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pixel" } - } - val setPixelv: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "set_pixelv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pixelv" } - } - val shrinkX2: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "shrink_x2".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shrink_x2" } - } - val srgbToLinear: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "srgb_to_linear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method srgb_to_linear" } - } - val unlock: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, - "unlock".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method unlock" } - }} + val blendRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "blend_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method blend_rect" } + } + } + + val blendRectMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "blend_rect_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method blend_rect_mask" } + } + } + + val blitRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "blit_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method blit_rect" } + } + } + + val blitRectMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "blit_rect_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method blit_rect_mask" } + } + } + + val bumpmapToNormalmap: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "bumpmap_to_normalmap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method bumpmap_to_normalmap" } + } + } + + val clearMipmaps: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "clear_mipmaps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_mipmaps" } + } + } + + val compress: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "compress".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method compress" } + } + } + + val convert: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "convert".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method convert" } + } + } + + val copyFrom: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "copy_from".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method copy_from" } + } + } + + val create: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create" } + } + } + + val createFromData: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "create_from_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_from_data" } + } + } + + val crop: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "crop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method crop" } + } + } + + val decompress: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "decompress".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method decompress" } + } + } + + val detectAlpha: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "detect_alpha".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method detect_alpha" } + } + } + + val expandX2Hq2x: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "expand_x2_hq2x".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method expand_x2_hq2x" } + } + } + + val fill: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "fill".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method fill" } + } + } + + val fixAlphaEdges: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "fix_alpha_edges".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method fix_alpha_edges" } + } + } + + val flipX: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "flip_x".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method flip_x" } + } + } + + val flipY: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "flip_y".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method flip_y" } + } + } + + val generateMipmaps: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "generate_mipmaps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method generate_mipmaps" } + } + } + + val getData: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "get_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_data" } + } + } + + val getFormat: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "get_format".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_format" } + } + } + + val getHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "get_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_height" } + } + } + + val getMipmapOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "get_mipmap_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mipmap_offset" } + } + } + + val getPixel: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "get_pixel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pixel" } + } + } + + val getPixelv: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "get_pixelv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pixelv" } + } + } + + val getRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "get_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rect" } + } + } + + val getSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "get_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_size" } + } + } + + val getUsedRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "get_used_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_used_rect" } + } + } + + val getWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "get_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_width" } + } + } + + val hasMipmaps: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "has_mipmaps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_mipmaps" } + } + } + + val isCompressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "is_compressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_compressed" } + } + } + + val isEmpty: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "is_empty".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_empty" } + } + } + + val isInvisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "is_invisible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_invisible" } + } + } + + val load: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "load".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method load" } + } + } + + val loadJpgFromBuffer: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "load_jpg_from_buffer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method load_jpg_from_buffer" } + } + } + + val loadPngFromBuffer: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "load_png_from_buffer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method load_png_from_buffer" } + } + } + + val loadWebpFromBuffer: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "load_webp_from_buffer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method load_webp_from_buffer" } + } + } + + val lock: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "lock".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method lock" } + } + } + + val normalmapToXy: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "normalmap_to_xy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method normalmap_to_xy" } + } + } + + val premultiplyAlpha: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "premultiply_alpha".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method premultiply_alpha" } + } + } + + val resize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "resize".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method resize" } + } + } + + val resizeToPo2: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "resize_to_po2".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method resize_to_po2" } + } + } + + val rgbeToSrgb: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "rgbe_to_srgb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rgbe_to_srgb" } + } + } + + val saveExr: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "save_exr".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method save_exr" } + } + } + + val savePng: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "save_png".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method save_png" } + } + } + + val setPixel: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "set_pixel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pixel" } + } + } + + val setPixelv: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "set_pixelv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pixelv" } + } + } + + val shrinkX2: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "shrink_x2".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shrink_x2" } + } + } + + val srgbToLinear: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "srgb_to_linear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method srgb_to_linear" } + } + } + + val unlock: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Image".cstr.ptr, + "unlock".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method unlock" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ImageTexture.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ImageTexture.kt index f16b3c05..efc4500a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ImageTexture.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ImageTexture.kt @@ -188,75 +188,95 @@ open class ImageTexture( * Container for method_bind pointers for ImageTexture */ private object __method_bind { - val create: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, - "create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create" } - } - val createFromImage: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, - "create_from_image".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_from_image" } - } - val getFormat: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, - "get_format".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_format" } - } - val getLossyStorageQuality: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, - "get_lossy_storage_quality".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_lossy_storage_quality" } - } - val getStorage: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, - "get_storage".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_storage" } - } - val load: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, - "load".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method load" } - } - val setData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, - "set_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_data" } - } - val setLossyStorageQuality: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, - "set_lossy_storage_quality".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_lossy_storage_quality" } - } - val setSizeOverride: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, - "set_size_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_size_override" } - } - val setStorage: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, - "set_storage".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_storage" } - }} + val create: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, + "create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create" } + } + } + + val createFromImage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, + "create_from_image".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_from_image" } + } + } + + val getFormat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, + "get_format".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_format" } + } + } + + val getLossyStorageQuality: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, + "get_lossy_storage_quality".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_lossy_storage_quality" } + } + } + + val getStorage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, + "get_storage".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_storage" } + } + } + + val load: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, + "load".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method load" } + } + } + + val setData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, + "set_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_data" } + } + } + + val setLossyStorageQuality: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, + "set_lossy_storage_quality".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_lossy_storage_quality" } + } + } + + val setSizeOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, + "set_size_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_size_override" } + } + } + + val setStorage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImageTexture".cstr.ptr, + "set_storage".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_storage" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ImmediateGeometry.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ImmediateGeometry.kt index efbd3b58..290955e4 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ImmediateGeometry.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ImmediateGeometry.kt @@ -138,75 +138,95 @@ open class ImmediateGeometry( * Container for method_bind pointers for ImmediateGeometry */ private object __method_bind { - val addSphere: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, - "add_sphere".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_sphere" } - } - val addVertex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, - "add_vertex".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_vertex" } - } - val begin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, - "begin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method begin" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val end: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, - "end".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method end" } - } - val setColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, - "set_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_color" } - } - val setNormal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, - "set_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_normal" } - } - val setTangent: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, - "set_tangent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tangent" } - } - val setUv: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, - "set_uv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_uv" } - } - val setUv2: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, - "set_uv2".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_uv2" } - }} + val addSphere: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, + "add_sphere".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_sphere" } + } + } + + val addVertex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, + "add_vertex".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_vertex" } + } + } + + val begin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, + "begin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method begin" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val end: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, + "end".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method end" } + } + } + + val setColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, + "set_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_color" } + } + } + + val setNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, + "set_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_normal" } + } + } + + val setTangent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, + "set_tangent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tangent" } + } + } + + val setUv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, + "set_uv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_uv" } + } + } + + val setUv2: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ImmediateGeometry".cstr.ptr, + "set_uv2".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_uv2" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Input.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Input.kt index 6e7961d8..8144a0de 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Input.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Input.kt @@ -454,246 +454,328 @@ open class InputInternal( * Container for method_bind pointers for Input */ private object __method_bind { - val actionPress: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "action_press".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method action_press" } - } - val actionRelease: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "action_release".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method action_release" } - } - val addJoyMapping: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "add_joy_mapping".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_joy_mapping" } - } - val getAccelerometer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "get_accelerometer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_accelerometer" } - } - val getActionStrength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "get_action_strength".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_action_strength" } - } - val getConnectedJoypads: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "get_connected_joypads".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connected_joypads" } - } - val getCurrentCursorShape: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "get_current_cursor_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_cursor_shape" } - } - val getGravity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "get_gravity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gravity" } - } - val getGyroscope: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "get_gyroscope".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gyroscope" } - } - val getJoyAxis: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "get_joy_axis".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_joy_axis" } - } - val getJoyAxisIndexFromString: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "get_joy_axis_index_from_string".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_joy_axis_index_from_string" } - } - val getJoyAxisString: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "get_joy_axis_string".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_joy_axis_string" } - } - val getJoyButtonIndexFromString: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "get_joy_button_index_from_string".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_joy_button_index_from_string" } - } - val getJoyButtonString: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "get_joy_button_string".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_joy_button_string" } - } - val getJoyGuid: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "get_joy_guid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_joy_guid" } - } - val getJoyName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "get_joy_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_joy_name" } - } - val getJoyVibrationDuration: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "get_joy_vibration_duration".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_joy_vibration_duration" } - } - val getJoyVibrationStrength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "get_joy_vibration_strength".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_joy_vibration_strength" } - } - val getLastMouseSpeed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "get_last_mouse_speed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_last_mouse_speed" } - } - val getMagnetometer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "get_magnetometer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_magnetometer" } - } - val getMouseButtonMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "get_mouse_button_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mouse_button_mask" } - } - val getMouseMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "get_mouse_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mouse_mode" } - } - val isActionJustPressed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "is_action_just_pressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_action_just_pressed" } - } - val isActionJustReleased: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "is_action_just_released".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_action_just_released" } - } - val isActionPressed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "is_action_pressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_action_pressed" } - } - val isJoyButtonPressed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "is_joy_button_pressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_joy_button_pressed" } - } - val isJoyKnown: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "is_joy_known".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_joy_known" } - } - val isKeyPressed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "is_key_pressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_key_pressed" } - } - val isMouseButtonPressed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "is_mouse_button_pressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_mouse_button_pressed" } - } - val joyConnectionChanged: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "joy_connection_changed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method joy_connection_changed" } - } - val parseInputEvent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "parse_input_event".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method parse_input_event" } - } - val removeJoyMapping: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "remove_joy_mapping".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_joy_mapping" } - } - val setCustomMouseCursor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "set_custom_mouse_cursor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_custom_mouse_cursor" } - } - val setDefaultCursorShape: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "set_default_cursor_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_default_cursor_shape" } - } - val setMouseMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "set_mouse_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mouse_mode" } - } - val setUseAccumulatedInput: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "set_use_accumulated_input".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_accumulated_input" } - } - val startJoyVibration: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "start_joy_vibration".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method start_joy_vibration" } - } - val stopJoyVibration: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "stop_joy_vibration".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method stop_joy_vibration" } - } - val vibrateHandheld: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "vibrate_handheld".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method vibrate_handheld" } - } - val warpMousePosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, - "warp_mouse_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method warp_mouse_position" } - }} + val actionPress: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "action_press".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method action_press" } + } + } + + val actionRelease: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "action_release".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method action_release" } + } + } + + val addJoyMapping: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "add_joy_mapping".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_joy_mapping" } + } + } + + val getAccelerometer: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "get_accelerometer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_accelerometer" } + } + } + + val getActionStrength: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "get_action_strength".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_action_strength" } + } + } + + val getConnectedJoypads: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "get_connected_joypads".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connected_joypads" } + } + } + + val getCurrentCursorShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "get_current_cursor_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_cursor_shape" } + } + } + + val getGravity: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "get_gravity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gravity" } + } + } + + val getGyroscope: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "get_gyroscope".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gyroscope" } + } + } + + val getJoyAxis: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "get_joy_axis".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_joy_axis" } + } + } + + val getJoyAxisIndexFromString: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "get_joy_axis_index_from_string".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_joy_axis_index_from_string" + } + } + } + + val getJoyAxisString: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "get_joy_axis_string".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_joy_axis_string" } + } + } + + val getJoyButtonIndexFromString: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "get_joy_button_index_from_string".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_joy_button_index_from_string" } + } + } + + val getJoyButtonString: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "get_joy_button_string".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_joy_button_string" } + } + } + + val getJoyGuid: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "get_joy_guid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_joy_guid" } + } + } + + val getJoyName: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "get_joy_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_joy_name" } + } + } + + val getJoyVibrationDuration: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "get_joy_vibration_duration".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_joy_vibration_duration" } + } + } + + val getJoyVibrationStrength: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "get_joy_vibration_strength".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_joy_vibration_strength" } + } + } + + val getLastMouseSpeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "get_last_mouse_speed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_last_mouse_speed" } + } + } + + val getMagnetometer: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "get_magnetometer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_magnetometer" } + } + } + + val getMouseButtonMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "get_mouse_button_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mouse_button_mask" } + } + } + + val getMouseMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "get_mouse_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mouse_mode" } + } + } + + val isActionJustPressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "is_action_just_pressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_action_just_pressed" } + } + } + + val isActionJustReleased: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "is_action_just_released".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_action_just_released" } + } + } + + val isActionPressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "is_action_pressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_action_pressed" } + } + } + + val isJoyButtonPressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "is_joy_button_pressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_joy_button_pressed" } + } + } + + val isJoyKnown: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "is_joy_known".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_joy_known" } + } + } + + val isKeyPressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "is_key_pressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_key_pressed" } + } + } + + val isMouseButtonPressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "is_mouse_button_pressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_mouse_button_pressed" } + } + } + + val joyConnectionChanged: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "joy_connection_changed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method joy_connection_changed" } + } + } + + val parseInputEvent: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "parse_input_event".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method parse_input_event" } + } + } + + val removeJoyMapping: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "remove_joy_mapping".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_joy_mapping" } + } + } + + val setCustomMouseCursor: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "set_custom_mouse_cursor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_custom_mouse_cursor" } + } + } + + val setDefaultCursorShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "set_default_cursor_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_default_cursor_shape" } + } + } + + val setMouseMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "set_mouse_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mouse_mode" } + } + } + + val setUseAccumulatedInput: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "set_use_accumulated_input".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_accumulated_input" } + } + } + + val startJoyVibration: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "start_joy_vibration".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method start_joy_vibration" } + } + } + + val stopJoyVibration: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "stop_joy_vibration".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method stop_joy_vibration" } + } + } + + val vibrateHandheld: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "vibrate_handheld".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method vibrate_handheld" } + } + } + + val warpMousePosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Input".cstr.ptr, + "warp_mouse_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method warp_mouse_position" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/InputEvent.kt b/godot-kotlin/src/nativeGen/kotlin/godot/InputEvent.kt index e2e4cc8b..d431db0e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/InputEvent.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/InputEvent.kt @@ -190,83 +190,122 @@ open class InputEvent( * Container for method_bind pointers for InputEvent */ private object __method_bind { - val accumulate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, - "accumulate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method accumulate" } - } - val asText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, - "as_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method as_text" } - } - val getActionStrength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, - "get_action_strength".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_action_strength" } - } - val getDevice: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, - "get_device".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_device" } - } - val isAction: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, - "is_action".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_action" } - } - val isActionPressed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, - "is_action_pressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_action_pressed" } - } - val isActionReleased: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, - "is_action_released".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_action_released" } - } - val isActionType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, - "is_action_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_action_type" } - } - val isEcho: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, - "is_echo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_echo" } - } - val isPressed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, - "is_pressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_pressed" } - } - val setDevice: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, - "set_device".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_device" } - } - val shortcutMatch: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, - "shortcut_match".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shortcut_match" } - } - val xformedBy: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, - "xformed_by".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method xformed_by" } - }} + val accumulate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, + "accumulate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method accumulate" } + } + } + + val asText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, + "as_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method as_text" } + } + } + + val getActionStrength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, + "get_action_strength".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_action_strength" } + } + } + + val getDevice: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, + "get_device".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_device" } + } + } + + val isAction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, + "is_action".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_action" } + } + } + + val isActionPressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, + "is_action_pressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_action_pressed" } + } + } + + val isActionReleased: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, + "is_action_released".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_action_released" } + } + } + + val isActionType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, + "is_action_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_action_type" } + } + } + + val isEcho: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, + "is_echo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_echo" } + } + } + + val isPressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, + "is_pressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_pressed" } + } + } + + val setDevice: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, + "set_device".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_device" } + } + } + + val shortcutMatch: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, + "shortcut_match".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shortcut_match" } + } + } + + val xformedBy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEvent".cstr.ptr, + "xformed_by".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method xformed_by" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventAction.kt b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventAction.kt index 60eec530..f5021b50 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventAction.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventAction.kt @@ -116,40 +116,50 @@ open class InputEventAction( * Container for method_bind pointers for InputEventAction */ private object __method_bind { - val getAction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventAction".cstr.ptr, - "get_action".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_action" } - } - val getStrength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventAction".cstr.ptr, - "get_strength".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_strength" } - } - val setAction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventAction".cstr.ptr, - "set_action".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_action" } - } - val setPressed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventAction".cstr.ptr, - "set_pressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pressed" } - } - val setStrength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventAction".cstr.ptr, - "set_strength".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_strength" } - }} + val getAction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventAction".cstr.ptr, + "get_action".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_action" } + } + } + + val getStrength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventAction".cstr.ptr, + "get_strength".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_strength" } + } + } + + val setAction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventAction".cstr.ptr, + "set_action".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_action" } + } + } + + val setPressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventAction".cstr.ptr, + "set_pressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pressed" } + } + } + + val setStrength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventAction".cstr.ptr, + "set_strength".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_strength" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventGesture.kt b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventGesture.kt index c2f27c2f..2cf3619f 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventGesture.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventGesture.kt @@ -78,19 +78,23 @@ open class InputEventGesture( * Container for method_bind pointers for InputEventGesture */ private object __method_bind { - val getPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventGesture".cstr.ptr, - "get_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_position" } - } - val setPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventGesture".cstr.ptr, - "set_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_position" } - }} + val getPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventGesture".cstr.ptr, + "get_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_position" } + } + } + + val setPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventGesture".cstr.ptr, + "set_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_position" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventJoypadButton.kt b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventJoypadButton.kt index 79e638ab..60e61aab 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventJoypadButton.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventJoypadButton.kt @@ -116,40 +116,50 @@ open class InputEventJoypadButton( * Container for method_bind pointers for InputEventJoypadButton */ private object __method_bind { - val getButtonIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventJoypadButton".cstr.ptr, - "get_button_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_button_index" } - } - val getPressure: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventJoypadButton".cstr.ptr, - "get_pressure".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pressure" } - } - val setButtonIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventJoypadButton".cstr.ptr, - "set_button_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_button_index" } - } - val setPressed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventJoypadButton".cstr.ptr, - "set_pressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pressed" } - } - val setPressure: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventJoypadButton".cstr.ptr, - "set_pressure".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pressure" } - }} + val getButtonIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventJoypadButton".cstr.ptr, + "get_button_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_button_index" } + } + } + + val getPressure: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventJoypadButton".cstr.ptr, + "get_pressure".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pressure" } + } + } + + val setButtonIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventJoypadButton".cstr.ptr, + "set_button_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_button_index" } + } + } + + val setPressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventJoypadButton".cstr.ptr, + "set_pressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pressed" } + } + } + + val setPressure: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventJoypadButton".cstr.ptr, + "set_pressure".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pressure" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventJoypadMotion.kt b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventJoypadMotion.kt index a9870bb5..431add41 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventJoypadMotion.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventJoypadMotion.kt @@ -100,33 +100,41 @@ open class InputEventJoypadMotion( * Container for method_bind pointers for InputEventJoypadMotion */ private object __method_bind { - val getAxis: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventJoypadMotion".cstr.ptr, - "get_axis".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_axis" } - } - val getAxisValue: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventJoypadMotion".cstr.ptr, - "get_axis_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_axis_value" } - } - val setAxis: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventJoypadMotion".cstr.ptr, - "set_axis".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_axis" } - } - val setAxisValue: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventJoypadMotion".cstr.ptr, - "set_axis_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_axis_value" } - }} + val getAxis: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventJoypadMotion".cstr.ptr, + "get_axis".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_axis" } + } + } + + val getAxisValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventJoypadMotion".cstr.ptr, + "get_axis_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_axis_value" } + } + } + + val setAxis: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventJoypadMotion".cstr.ptr, + "set_axis".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_axis" } + } + } + + val setAxisValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventJoypadMotion".cstr.ptr, + "set_axis_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_axis_value" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventKey.kt b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventKey.kt index a8c5bb1b..bb5a1124 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventKey.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventKey.kt @@ -139,54 +139,68 @@ open class InputEventKey( * Container for method_bind pointers for InputEventKey */ private object __method_bind { - val getScancode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventKey".cstr.ptr, - "get_scancode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_scancode" } - } - val getScancodeWithModifiers: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventKey".cstr.ptr, - "get_scancode_with_modifiers".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_scancode_with_modifiers" } - } - val getUnicode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventKey".cstr.ptr, - "get_unicode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_unicode" } - } - val setEcho: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventKey".cstr.ptr, - "set_echo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_echo" } - } - val setPressed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventKey".cstr.ptr, - "set_pressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pressed" } - } - val setScancode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventKey".cstr.ptr, - "set_scancode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_scancode" } - } - val setUnicode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventKey".cstr.ptr, - "set_unicode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_unicode" } - }} + val getScancode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventKey".cstr.ptr, + "get_scancode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_scancode" } + } + } + + val getScancodeWithModifiers: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventKey".cstr.ptr, + "get_scancode_with_modifiers".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_scancode_with_modifiers" } + } + } + + val getUnicode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventKey".cstr.ptr, + "get_unicode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_unicode" } + } + } + + val setEcho: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventKey".cstr.ptr, + "set_echo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_echo" } + } + } + + val setPressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventKey".cstr.ptr, + "set_pressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pressed" } + } + } + + val setScancode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventKey".cstr.ptr, + "set_scancode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_scancode" } + } + } + + val setUnicode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventKey".cstr.ptr, + "set_unicode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_unicode" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMIDI.kt b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMIDI.kt index a56df04b..ba5f94fb 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMIDI.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMIDI.kt @@ -249,117 +249,149 @@ open class InputEventMIDI( * Container for method_bind pointers for InputEventMIDI */ private object __method_bind { - val getChannel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, - "get_channel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_channel" } - } - val getControllerNumber: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, - "get_controller_number".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_controller_number" } - } - val getControllerValue: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, - "get_controller_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_controller_value" } - } - val getInstrument: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, - "get_instrument".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_instrument" } - } - val getMessage: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, - "get_message".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_message" } - } - val getPitch: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, - "get_pitch".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pitch" } - } - val getPressure: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, - "get_pressure".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pressure" } - } - val getVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, - "get_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_velocity" } - } - val setChannel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, - "set_channel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_channel" } - } - val setControllerNumber: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, - "set_controller_number".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_controller_number" } - } - val setControllerValue: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, - "set_controller_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_controller_value" } - } - val setInstrument: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, - "set_instrument".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_instrument" } - } - val setMessage: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, - "set_message".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_message" } - } - val setPitch: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, - "set_pitch".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pitch" } - } - val setPressure: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, - "set_pressure".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pressure" } - } - val setVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, - "set_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_velocity" } - }} + val getChannel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, + "get_channel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_channel" } + } + } + + val getControllerNumber: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, + "get_controller_number".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_controller_number" } + } + } + + val getControllerValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, + "get_controller_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_controller_value" } + } + } + + val getInstrument: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, + "get_instrument".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_instrument" } + } + } + + val getMessage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, + "get_message".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_message" } + } + } + + val getPitch: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, + "get_pitch".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pitch" } + } + } + + val getPressure: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, + "get_pressure".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pressure" } + } + } + + val getVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, + "get_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_velocity" } + } + } + + val setChannel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, + "set_channel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_channel" } + } + } + + val setControllerNumber: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, + "set_controller_number".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_controller_number" } + } + } + + val setControllerValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, + "set_controller_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_controller_value" } + } + } + + val setInstrument: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, + "set_instrument".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_instrument" } + } + } + + val setMessage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, + "set_message".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_message" } + } + } + + val setPitch: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, + "set_pitch".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pitch" } + } + } + + val setPressure: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, + "set_pressure".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pressure" } + } + } + + val setVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMIDI".cstr.ptr, + "set_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_velocity" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMagnifyGesture.kt b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMagnifyGesture.kt index 5eaa9be1..dfb264e4 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMagnifyGesture.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMagnifyGesture.kt @@ -74,19 +74,23 @@ open class InputEventMagnifyGesture( * Container for method_bind pointers for InputEventMagnifyGesture */ private object __method_bind { - val getFactor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMagnifyGesture".cstr.ptr, - "get_factor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_factor" } - } - val setFactor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMagnifyGesture".cstr.ptr, - "set_factor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_factor" } - }} + val getFactor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMagnifyGesture".cstr.ptr, + "get_factor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_factor" } + } + } + + val setFactor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMagnifyGesture".cstr.ptr, + "set_factor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_factor" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMouse.kt b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMouse.kt index 1ec47055..1c383e08 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMouse.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMouse.kt @@ -139,47 +139,59 @@ open class InputEventMouse( * Container for method_bind pointers for InputEventMouse */ private object __method_bind { - val getButtonMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouse".cstr.ptr, - "get_button_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_button_mask" } - } - val getGlobalPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouse".cstr.ptr, - "get_global_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_global_position" } - } - val getPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouse".cstr.ptr, - "get_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_position" } - } - val setButtonMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouse".cstr.ptr, - "set_button_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_button_mask" } - } - val setGlobalPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouse".cstr.ptr, - "set_global_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_global_position" } - } - val setPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouse".cstr.ptr, - "set_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_position" } - }} + val getButtonMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouse".cstr.ptr, + "get_button_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_button_mask" } + } + } + + val getGlobalPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouse".cstr.ptr, + "get_global_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_global_position" } + } + } + + val getPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouse".cstr.ptr, + "get_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_position" } + } + } + + val setButtonMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouse".cstr.ptr, + "set_button_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_button_mask" } + } + } + + val setGlobalPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouse".cstr.ptr, + "set_global_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_global_position" } + } + } + + val setPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouse".cstr.ptr, + "set_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_position" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMouseButton.kt b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMouseButton.kt index 2b0fba80..9c9d7a65 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMouseButton.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMouseButton.kt @@ -141,54 +141,68 @@ open class InputEventMouseButton( * Container for method_bind pointers for InputEventMouseButton */ private object __method_bind { - val getButtonIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseButton".cstr.ptr, - "get_button_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_button_index" } - } - val getFactor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseButton".cstr.ptr, - "get_factor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_factor" } - } - val isDoubleclick: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseButton".cstr.ptr, - "is_doubleclick".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_doubleclick" } - } - val setButtonIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseButton".cstr.ptr, - "set_button_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_button_index" } - } - val setDoubleclick: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseButton".cstr.ptr, - "set_doubleclick".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_doubleclick" } - } - val setFactor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseButton".cstr.ptr, - "set_factor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_factor" } - } - val setPressed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseButton".cstr.ptr, - "set_pressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pressed" } - }} + val getButtonIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseButton".cstr.ptr, + "get_button_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_button_index" } + } + } + + val getFactor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseButton".cstr.ptr, + "get_factor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_factor" } + } + } + + val isDoubleclick: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseButton".cstr.ptr, + "is_doubleclick".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_doubleclick" } + } + } + + val setButtonIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseButton".cstr.ptr, + "set_button_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_button_index" } + } + } + + val setDoubleclick: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseButton".cstr.ptr, + "set_doubleclick".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_doubleclick" } + } + } + + val setFactor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseButton".cstr.ptr, + "set_factor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_factor" } + } + } + + val setPressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseButton".cstr.ptr, + "set_pressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pressed" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMouseMotion.kt b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMouseMotion.kt index e7d0ac00..11fd7946 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMouseMotion.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventMouseMotion.kt @@ -181,61 +181,77 @@ open class InputEventMouseMotion( * Container for method_bind pointers for InputEventMouseMotion */ private object __method_bind { - val getPressure: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseMotion".cstr.ptr, - "get_pressure".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pressure" } - } - val getRelative: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseMotion".cstr.ptr, - "get_relative".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_relative" } - } - val getSpeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseMotion".cstr.ptr, - "get_speed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_speed" } - } - val getTilt: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseMotion".cstr.ptr, - "get_tilt".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tilt" } - } - val setPressure: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseMotion".cstr.ptr, - "set_pressure".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pressure" } - } - val setRelative: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseMotion".cstr.ptr, - "set_relative".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_relative" } - } - val setSpeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseMotion".cstr.ptr, - "set_speed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_speed" } - } - val setTilt: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseMotion".cstr.ptr, - "set_tilt".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tilt" } - }} + val getPressure: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseMotion".cstr.ptr, + "get_pressure".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pressure" } + } + } + + val getRelative: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseMotion".cstr.ptr, + "get_relative".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_relative" } + } + } + + val getSpeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseMotion".cstr.ptr, + "get_speed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_speed" } + } + } + + val getTilt: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseMotion".cstr.ptr, + "get_tilt".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tilt" } + } + } + + val setPressure: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseMotion".cstr.ptr, + "set_pressure".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pressure" } + } + } + + val setRelative: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseMotion".cstr.ptr, + "set_relative".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_relative" } + } + } + + val setSpeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseMotion".cstr.ptr, + "set_speed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_speed" } + } + } + + val setTilt: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventMouseMotion".cstr.ptr, + "set_tilt".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tilt" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventPanGesture.kt b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventPanGesture.kt index 2994d4e0..b99c8d23 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventPanGesture.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventPanGesture.kt @@ -85,19 +85,23 @@ open class InputEventPanGesture( * Container for method_bind pointers for InputEventPanGesture */ private object __method_bind { - val getDelta: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventPanGesture".cstr.ptr, - "get_delta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_delta" } - } - val setDelta: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventPanGesture".cstr.ptr, - "set_delta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_delta" } - }} + val getDelta: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventPanGesture".cstr.ptr, + "get_delta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_delta" } + } + } + + val setDelta: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventPanGesture".cstr.ptr, + "set_delta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_delta" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventScreenDrag.kt b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventScreenDrag.kt index 943297b3..81246160 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventScreenDrag.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventScreenDrag.kt @@ -181,61 +181,77 @@ open class InputEventScreenDrag( * Container for method_bind pointers for InputEventScreenDrag */ private object __method_bind { - val getIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenDrag".cstr.ptr, - "get_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_index" } - } - val getPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenDrag".cstr.ptr, - "get_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_position" } - } - val getRelative: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenDrag".cstr.ptr, - "get_relative".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_relative" } - } - val getSpeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenDrag".cstr.ptr, - "get_speed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_speed" } - } - val setIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenDrag".cstr.ptr, - "set_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_index" } - } - val setPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenDrag".cstr.ptr, - "set_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_position" } - } - val setRelative: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenDrag".cstr.ptr, - "set_relative".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_relative" } - } - val setSpeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenDrag".cstr.ptr, - "set_speed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_speed" } - }} + val getIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenDrag".cstr.ptr, + "get_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_index" } + } + } + + val getPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenDrag".cstr.ptr, + "get_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_position" } + } + } + + val getRelative: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenDrag".cstr.ptr, + "get_relative".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_relative" } + } + } + + val getSpeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenDrag".cstr.ptr, + "get_speed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_speed" } + } + } + + val setIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenDrag".cstr.ptr, + "set_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_index" } + } + } + + val setPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenDrag".cstr.ptr, + "set_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_position" } + } + } + + val setRelative: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenDrag".cstr.ptr, + "set_relative".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_relative" } + } + } + + val setSpeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenDrag".cstr.ptr, + "set_speed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_speed" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventScreenTouch.kt b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventScreenTouch.kt index 4346c478..9fa23d4f 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventScreenTouch.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventScreenTouch.kt @@ -127,40 +127,50 @@ open class InputEventScreenTouch( * Container for method_bind pointers for InputEventScreenTouch */ private object __method_bind { - val getIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenTouch".cstr.ptr, - "get_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_index" } - } - val getPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenTouch".cstr.ptr, - "get_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_position" } - } - val setIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenTouch".cstr.ptr, - "set_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_index" } - } - val setPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenTouch".cstr.ptr, - "set_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_position" } - } - val setPressed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenTouch".cstr.ptr, - "set_pressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pressed" } - }} + val getIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenTouch".cstr.ptr, + "get_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_index" } + } + } + + val getPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenTouch".cstr.ptr, + "get_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_position" } + } + } + + val setIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenTouch".cstr.ptr, + "set_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_index" } + } + } + + val setPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenTouch".cstr.ptr, + "set_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_position" } + } + } + + val setPressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventScreenTouch".cstr.ptr, + "set_pressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pressed" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventWithModifiers.kt b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventWithModifiers.kt index f9c2a2f1..74243d23 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/InputEventWithModifiers.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/InputEventWithModifiers.kt @@ -167,75 +167,95 @@ open class InputEventWithModifiers( * Container for method_bind pointers for InputEventWithModifiers */ private object __method_bind { - val getAlt: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, - "get_alt".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_alt" } - } - val getCommand: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, - "get_command".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_command" } - } - val getControl: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, - "get_control".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_control" } - } - val getMetakey: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, - "get_metakey".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_metakey" } - } - val getShift: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, - "get_shift".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shift" } - } - val setAlt: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, - "set_alt".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_alt" } - } - val setCommand: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, - "set_command".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_command" } - } - val setControl: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, - "set_control".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_control" } - } - val setMetakey: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, - "set_metakey".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_metakey" } - } - val setShift: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, - "set_shift".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shift" } - }} + val getAlt: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, + "get_alt".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_alt" } + } + } + + val getCommand: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, + "get_command".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_command" } + } + } + + val getControl: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, + "get_control".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_control" } + } + } + + val getMetakey: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, + "get_metakey".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_metakey" } + } + } + + val getShift: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, + "get_shift".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shift" } + } + } + + val setAlt: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, + "set_alt".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_alt" } + } + } + + val setCommand: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, + "set_command".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_command" } + } + } + + val setControl: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, + "set_control".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_control" } + } + } + + val setMetakey: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, + "set_metakey".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_metakey" } + } + } + + val setShift: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputEventWithModifiers".cstr.ptr, + "set_shift".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shift" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/InputMap.kt b/godot-kotlin/src/nativeGen/kotlin/godot/InputMap.kt index ae1342f3..7b2fee29 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/InputMap.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/InputMap.kt @@ -156,78 +156,114 @@ open class InputMapInternal( * Container for method_bind pointers for InputMap */ private object __method_bind { - val actionAddEvent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, - "action_add_event".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method action_add_event" } - } - val actionEraseEvent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, - "action_erase_event".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method action_erase_event" } - } - val actionEraseEvents: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, - "action_erase_events".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method action_erase_events" } - } - val actionHasEvent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, - "action_has_event".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method action_has_event" } - } - val actionSetDeadzone: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, - "action_set_deadzone".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method action_set_deadzone" } - } - val addAction: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, - "add_action".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_action" } - } - val eraseAction: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, - "erase_action".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method erase_action" } - } - val eventIsAction: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, - "event_is_action".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method event_is_action" } - } - val getActionList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, - "get_action_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_action_list" } - } - val getActions: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, - "get_actions".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_actions" } - } - val hasAction: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, - "has_action".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_action" } - } - val loadFromGlobals: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, - "load_from_globals".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method load_from_globals" } - }} + val actionAddEvent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, + "action_add_event".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method action_add_event" } + } + } + + val actionEraseEvent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, + "action_erase_event".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method action_erase_event" } + } + } + + val actionEraseEvents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, + "action_erase_events".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method action_erase_events" } + } + } + + val actionHasEvent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, + "action_has_event".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method action_has_event" } + } + } + + val actionSetDeadzone: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, + "action_set_deadzone".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method action_set_deadzone" } + } + } + + val addAction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, + "add_action".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_action" } + } + } + + val eraseAction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, + "erase_action".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method erase_action" } + } + } + + val eventIsAction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, + "event_is_action".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method event_is_action" } + } + } + + val getActionList: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, + "get_action_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_action_list" } + } + } + + val getActions: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, + "get_actions".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_actions" } + } + } + + val hasAction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, + "has_action".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_action" } + } + } + + val loadFromGlobals: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InputMap".cstr.ptr, + "load_from_globals".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method load_from_globals" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/InstancePlaceholder.kt b/godot-kotlin/src/nativeGen/kotlin/godot/InstancePlaceholder.kt index 951a8222..1a7fa893 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/InstancePlaceholder.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/InstancePlaceholder.kt @@ -87,33 +87,41 @@ open class InstancePlaceholder( * Container for method_bind pointers for InstancePlaceholder */ private object __method_bind { - val createInstance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InstancePlaceholder".cstr.ptr, - "create_instance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_instance" } - } - val getInstancePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InstancePlaceholder".cstr.ptr, - "get_instance_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_instance_path" } - } - val getStoredValues: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InstancePlaceholder".cstr.ptr, - "get_stored_values".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stored_values" } - } - val replaceByInstance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InstancePlaceholder".cstr.ptr, - "replace_by_instance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method replace_by_instance" } - }} + val createInstance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InstancePlaceholder".cstr.ptr, + "create_instance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_instance" } + } + } + + val getInstancePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InstancePlaceholder".cstr.ptr, + "get_instance_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_instance_path" } + } + } + + val getStoredValues: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InstancePlaceholder".cstr.ptr, + "get_stored_values".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stored_values" } + } + } + + val replaceByInstance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InstancePlaceholder".cstr.ptr, + "replace_by_instance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method replace_by_instance" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/InterpolatedCamera.kt b/godot-kotlin/src/nativeGen/kotlin/godot/InterpolatedCamera.kt index b9dab5fe..d5aad3c3 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/InterpolatedCamera.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/InterpolatedCamera.kt @@ -144,54 +144,68 @@ open class InterpolatedCamera( * Container for method_bind pointers for InterpolatedCamera */ private object __method_bind { - val getSpeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InterpolatedCamera".cstr.ptr, - "get_speed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_speed" } - } - val getTargetPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InterpolatedCamera".cstr.ptr, - "get_target_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_target_path" } - } - val isInterpolationEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InterpolatedCamera".cstr.ptr, - "is_interpolation_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_interpolation_enabled" } - } - val setInterpolationEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InterpolatedCamera".cstr.ptr, - "set_interpolation_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_interpolation_enabled" } - } - val setSpeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InterpolatedCamera".cstr.ptr, - "set_speed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_speed" } - } - val setTarget: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InterpolatedCamera".cstr.ptr, - "set_target".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_target" } - } - val setTargetPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InterpolatedCamera".cstr.ptr, - "set_target_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_target_path" } - }} + val getSpeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InterpolatedCamera".cstr.ptr, + "get_speed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_speed" } + } + } + + val getTargetPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InterpolatedCamera".cstr.ptr, + "get_target_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_target_path" } + } + } + + val isInterpolationEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InterpolatedCamera".cstr.ptr, + "is_interpolation_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_interpolation_enabled" } + } + } + + val setInterpolationEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InterpolatedCamera".cstr.ptr, + "set_interpolation_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_interpolation_enabled" } + } + } + + val setSpeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InterpolatedCamera".cstr.ptr, + "set_speed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_speed" } + } + } + + val setTarget: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InterpolatedCamera".cstr.ptr, + "set_target".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_target" } + } + } + + val setTargetPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("InterpolatedCamera".cstr.ptr, + "set_target_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_target_path" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ItemList.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ItemList.kt index 06ff620e..698d4f22 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ItemList.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ItemList.kt @@ -822,377 +822,563 @@ open class ItemList( * Container for method_bind pointers for ItemList */ private object __method_bind { - val addIconItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "add_icon_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_icon_item" } - } - val addItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "add_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_item" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val ensureCurrentIsVisible: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "ensure_current_is_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method ensure_current_is_visible" } - } - val getAllowReselect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_allow_reselect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_allow_reselect" } - } - val getAllowRmbSelect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_allow_rmb_select".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_allow_rmb_select" } - } - val getFixedColumnWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_fixed_column_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fixed_column_width" } - } - val getFixedIconSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_fixed_icon_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fixed_icon_size" } - } - val getIconMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_icon_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_icon_mode" } - } - val getIconScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_icon_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_icon_scale" } - } - val getItemAtPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_item_at_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_at_position" } - } - val getItemCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_item_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_count" } - } - val getItemCustomBgColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_item_custom_bg_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_custom_bg_color" } - } - val getItemCustomFgColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_item_custom_fg_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_custom_fg_color" } - } - val getItemIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_item_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_icon" } - } - val getItemIconModulate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_item_icon_modulate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_icon_modulate" } - } - val getItemIconRegion: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_item_icon_region".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_icon_region" } - } - val getItemMetadata: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_item_metadata".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_metadata" } - } - val getItemText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_item_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_text" } - } - val getItemTooltip: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_item_tooltip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_tooltip" } - } - val getMaxColumns: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_max_columns".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_max_columns" } - } - val getMaxTextLines: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_max_text_lines".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_max_text_lines" } - } - val getSelectMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_select_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_select_mode" } - } - val getSelectedItems: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_selected_items".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_selected_items" } - } - val getVScroll: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "get_v_scroll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_v_scroll" } - } - val hasAutoHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "has_auto_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_auto_height" } - } - val isAnythingSelected: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "is_anything_selected".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_anything_selected" } - } - val isItemDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "is_item_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_item_disabled" } - } - val isItemIconTransposed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "is_item_icon_transposed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_item_icon_transposed" } - } - val isItemSelectable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "is_item_selectable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_item_selectable" } - } - val isItemTooltipEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "is_item_tooltip_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_item_tooltip_enabled" } - } - val isSameColumnWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "is_same_column_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_same_column_width" } - } - val isSelected: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "is_selected".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_selected" } - } - val moveItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "move_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method move_item" } - } - val removeItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "remove_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_item" } - } - val select: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "select".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method select" } - } - val setAllowReselect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_allow_reselect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_allow_reselect" } - } - val setAllowRmbSelect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_allow_rmb_select".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_allow_rmb_select" } - } - val setAutoHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_auto_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_auto_height" } - } - val setFixedColumnWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_fixed_column_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fixed_column_width" } - } - val setFixedIconSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_fixed_icon_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fixed_icon_size" } - } - val setIconMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_icon_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_icon_mode" } - } - val setIconScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_icon_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_icon_scale" } - } - val setItemCustomBgColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_item_custom_bg_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_custom_bg_color" } - } - val setItemCustomFgColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_item_custom_fg_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_custom_fg_color" } - } - val setItemDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_item_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_disabled" } - } - val setItemIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_item_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_icon" } - } - val setItemIconModulate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_item_icon_modulate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_icon_modulate" } - } - val setItemIconRegion: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_item_icon_region".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_icon_region" } - } - val setItemIconTransposed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_item_icon_transposed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_icon_transposed" } - } - val setItemMetadata: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_item_metadata".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_metadata" } - } - val setItemSelectable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_item_selectable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_selectable" } - } - val setItemText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_item_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_text" } - } - val setItemTooltip: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_item_tooltip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_tooltip" } - } - val setItemTooltipEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_item_tooltip_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_tooltip_enabled" } - } - val setMaxColumns: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_max_columns".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_max_columns" } - } - val setMaxTextLines: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_max_text_lines".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_max_text_lines" } - } - val setSameColumnWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_same_column_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_same_column_width" } - } - val setSelectMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "set_select_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_select_mode" } - } - val sortItemsByText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "sort_items_by_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method sort_items_by_text" } - } - val unselect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "unselect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method unselect" } - } - val unselectAll: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, - "unselect_all".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method unselect_all" } - }} + val addIconItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "add_icon_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_icon_item" } + } + } + + val addItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "add_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_item" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val ensureCurrentIsVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "ensure_current_is_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method ensure_current_is_visible" } + } + } + + val getAllowReselect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_allow_reselect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_allow_reselect" } + } + } + + val getAllowRmbSelect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_allow_rmb_select".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_allow_rmb_select" } + } + } + + val getFixedColumnWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_fixed_column_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fixed_column_width" } + } + } + + val getFixedIconSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_fixed_icon_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fixed_icon_size" } + } + } + + val getIconMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_icon_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_icon_mode" } + } + } + + val getIconScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_icon_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_icon_scale" } + } + } + + val getItemAtPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_item_at_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_at_position" } + } + } + + val getItemCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_item_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_count" } + } + } + + val getItemCustomBgColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_item_custom_bg_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_custom_bg_color" } + } + } + + val getItemCustomFgColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_item_custom_fg_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_custom_fg_color" } + } + } + + val getItemIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_item_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_icon" } + } + } + + val getItemIconModulate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_item_icon_modulate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_icon_modulate" } + } + } + + val getItemIconRegion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_item_icon_region".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_icon_region" } + } + } + + val getItemMetadata: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_item_metadata".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_metadata" } + } + } + + val getItemText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_item_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_text" } + } + } + + val getItemTooltip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_item_tooltip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_tooltip" } + } + } + + val getMaxColumns: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_max_columns".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_max_columns" } + } + } + + val getMaxTextLines: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_max_text_lines".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_max_text_lines" } + } + } + + val getSelectMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_select_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_select_mode" } + } + } + + val getSelectedItems: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_selected_items".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_selected_items" } + } + } + + val getVScroll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "get_v_scroll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_v_scroll" } + } + } + + val hasAutoHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "has_auto_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_auto_height" } + } + } + + val isAnythingSelected: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "is_anything_selected".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_anything_selected" } + } + } + + val isItemDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "is_item_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_item_disabled" } + } + } + + val isItemIconTransposed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "is_item_icon_transposed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_item_icon_transposed" } + } + } + + val isItemSelectable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "is_item_selectable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_item_selectable" } + } + } + + val isItemTooltipEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "is_item_tooltip_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_item_tooltip_enabled" } + } + } + + val isSameColumnWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "is_same_column_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_same_column_width" } + } + } + + val isSelected: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "is_selected".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_selected" } + } + } + + val moveItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "move_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method move_item" } + } + } + + val removeItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "remove_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_item" } + } + } + + val select: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "select".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method select" } + } + } + + val setAllowReselect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_allow_reselect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_allow_reselect" } + } + } + + val setAllowRmbSelect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_allow_rmb_select".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_allow_rmb_select" } + } + } + + val setAutoHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_auto_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_auto_height" } + } + } + + val setFixedColumnWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_fixed_column_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fixed_column_width" } + } + } + + val setFixedIconSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_fixed_icon_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fixed_icon_size" } + } + } + + val setIconMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_icon_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_icon_mode" } + } + } + + val setIconScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_icon_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_icon_scale" } + } + } + + val setItemCustomBgColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_item_custom_bg_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_custom_bg_color" } + } + } + + val setItemCustomFgColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_item_custom_fg_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_custom_fg_color" } + } + } + + val setItemDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_item_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_disabled" } + } + } + + val setItemIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_item_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_icon" } + } + } + + val setItemIconModulate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_item_icon_modulate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_icon_modulate" } + } + } + + val setItemIconRegion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_item_icon_region".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_icon_region" } + } + } + + val setItemIconTransposed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_item_icon_transposed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_icon_transposed" } + } + } + + val setItemMetadata: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_item_metadata".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_metadata" } + } + } + + val setItemSelectable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_item_selectable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_selectable" } + } + } + + val setItemText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_item_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_text" } + } + } + + val setItemTooltip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_item_tooltip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_tooltip" } + } + } + + val setItemTooltipEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_item_tooltip_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_tooltip_enabled" } + } + } + + val setMaxColumns: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_max_columns".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_max_columns" } + } + } + + val setMaxTextLines: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_max_text_lines".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_max_text_lines" } + } + } + + val setSameColumnWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_same_column_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_same_column_width" } + } + } + + val setSelectMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "set_select_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_select_mode" } + } + } + + val sortItemsByText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "sort_items_by_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method sort_items_by_text" } + } + } + + val unselect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "unselect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method unselect" } + } + } + + val unselectAll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ItemList".cstr.ptr, + "unselect_all".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method unselect_all" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/JSON.kt b/godot-kotlin/src/nativeGen/kotlin/godot/JSON.kt index 2ca6bfaf..c6d871a6 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/JSON.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/JSON.kt @@ -67,18 +67,22 @@ open class JSONInternal( * Container for method_bind pointers for JSON */ private object __method_bind { - val parse: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_JSON".cstr.ptr, - "parse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method parse" } - } - val print: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_JSON".cstr.ptr, - "print".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method print" } - }} + val parse: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_JSON".cstr.ptr, + "parse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method parse" } + } + } + + val print: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_JSON".cstr.ptr, + "print".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method print" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/JSONParseResult.kt b/godot-kotlin/src/nativeGen/kotlin/godot/JSONParseResult.kt index 71349d69..62a872d4 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/JSONParseResult.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/JSONParseResult.kt @@ -162,61 +162,77 @@ open class JSONParseResult( * Container for method_bind pointers for JSONParseResult */ private object __method_bind { - val getError: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONParseResult".cstr.ptr, - "get_error".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_error" } - } - val getErrorLine: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONParseResult".cstr.ptr, - "get_error_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_error_line" } - } - val getErrorString: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONParseResult".cstr.ptr, - "get_error_string".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_error_string" } - } - val getResult: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONParseResult".cstr.ptr, - "get_result".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_result" } - } - val setError: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONParseResult".cstr.ptr, - "set_error".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_error" } - } - val setErrorLine: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONParseResult".cstr.ptr, - "set_error_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_error_line" } - } - val setErrorString: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONParseResult".cstr.ptr, - "set_error_string".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_error_string" } - } - val setResult: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONParseResult".cstr.ptr, - "set_result".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_result" } - }} + val getError: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONParseResult".cstr.ptr, + "get_error".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_error" } + } + } + + val getErrorLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONParseResult".cstr.ptr, + "get_error_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_error_line" } + } + } + + val getErrorString: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONParseResult".cstr.ptr, + "get_error_string".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_error_string" } + } + } + + val getResult: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONParseResult".cstr.ptr, + "get_result".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_result" } + } + } + + val setError: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONParseResult".cstr.ptr, + "set_error".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_error" } + } + } + + val setErrorLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONParseResult".cstr.ptr, + "set_error_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_error_line" } + } + } + + val setErrorString: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONParseResult".cstr.ptr, + "set_error_string".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_error_string" } + } + } + + val setResult: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONParseResult".cstr.ptr, + "set_result".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_result" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/JSONRPC.kt b/godot-kotlin/src/nativeGen/kotlin/godot/JSONRPC.kt index 1e70c8ba..cb9b5693 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/JSONRPC.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/JSONRPC.kt @@ -176,47 +176,68 @@ open class JSONRPC( * Container for method_bind pointers for JSONRPC */ private object __method_bind { - val makeNotification: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONRPC".cstr.ptr, - "make_notification".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method make_notification" } - } - val makeRequest: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONRPC".cstr.ptr, - "make_request".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method make_request" } - } - val makeResponse: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONRPC".cstr.ptr, - "make_response".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method make_response" } - } - val makeResponseError: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONRPC".cstr.ptr, - "make_response_error".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method make_response_error" } - } - val processAction: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONRPC".cstr.ptr, - "process_action".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method process_action" } - } - val processString: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONRPC".cstr.ptr, - "process_string".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method process_string" } - } - val setScope: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONRPC".cstr.ptr, - "set_scope".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_scope" } - }} + val makeNotification: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONRPC".cstr.ptr, + "make_notification".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method make_notification" } + } + } + + val makeRequest: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONRPC".cstr.ptr, + "make_request".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method make_request" } + } + } + + val makeResponse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONRPC".cstr.ptr, + "make_response".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method make_response" } + } + } + + val makeResponseError: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONRPC".cstr.ptr, + "make_response_error".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method make_response_error" } + } + } + + val processAction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONRPC".cstr.ptr, + "process_action".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method process_action" } + } + } + + val processString: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONRPC".cstr.ptr, + "process_string".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method process_string" } + } + } + + val setScope: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JSONRPC".cstr.ptr, + "set_scope".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_scope" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/JavaClassWrapper.kt b/godot-kotlin/src/nativeGen/kotlin/godot/JavaClassWrapper.kt index 56c8a6fb..9c48f53a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/JavaClassWrapper.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/JavaClassWrapper.kt @@ -47,13 +47,15 @@ open class JavaClassWrapperInternal( * Container for method_bind pointers for JavaClassWrapper */ private object __method_bind { - val wrap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JavaClassWrapper".cstr.ptr, - "wrap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method wrap" } - }} + val wrap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JavaClassWrapper".cstr.ptr, + "wrap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method wrap" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/JavaScript.kt b/godot-kotlin/src/nativeGen/kotlin/godot/JavaScript.kt index a7346407..59bfb8ae 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/JavaScript.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/JavaScript.kt @@ -50,12 +50,15 @@ open class JavaScriptInternal( * Container for method_bind pointers for JavaScript */ private object __method_bind { - val eval: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JavaScript".cstr.ptr, - "eval".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method eval" } - }} + val eval: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("JavaScript".cstr.ptr, + "eval".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method eval" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Joint.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Joint.kt index 67738f29..67db9a14 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Joint.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Joint.kt @@ -165,53 +165,71 @@ open class Joint( * Container for method_bind pointers for Joint */ private object __method_bind { - val getExcludeNodesFromCollision: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint".cstr.ptr, - "get_exclude_nodes_from_collision".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_exclude_nodes_from_collision" } - } - val getNodeA: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint".cstr.ptr, - "get_node_a".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_a" } - } - val getNodeB: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint".cstr.ptr, - "get_node_b".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_b" } - } - val getSolverPriority: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint".cstr.ptr, - "get_solver_priority".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_solver_priority" } - } - val setExcludeNodesFromCollision: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint".cstr.ptr, - "set_exclude_nodes_from_collision".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_exclude_nodes_from_collision" } - } - val setNodeA: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint".cstr.ptr, - "set_node_a".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_node_a" } - } - val setNodeB: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint".cstr.ptr, - "set_node_b".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_node_b" } - } - val setSolverPriority: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint".cstr.ptr, - "set_solver_priority".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_solver_priority" } - }} + val getExcludeNodesFromCollision: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint".cstr.ptr, + "get_exclude_nodes_from_collision".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_exclude_nodes_from_collision" } + } + } + + val getNodeA: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint".cstr.ptr, + "get_node_a".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_a" } + } + } + + val getNodeB: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint".cstr.ptr, + "get_node_b".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_b" } + } + } + + val getSolverPriority: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint".cstr.ptr, + "get_solver_priority".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_solver_priority" } + } + } + + val setExcludeNodesFromCollision: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint".cstr.ptr, + "set_exclude_nodes_from_collision".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_exclude_nodes_from_collision" } + } + } + + val setNodeA: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint".cstr.ptr, + "set_node_a".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_node_a" } + } + } + + val setNodeB: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint".cstr.ptr, + "set_node_b".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_node_b" } + } + } + + val setSolverPriority: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint".cstr.ptr, + "set_solver_priority".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_solver_priority" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Joint2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Joint2D.kt index 04c2e085..b9692d9d 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Joint2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Joint2D.kt @@ -165,53 +165,79 @@ open class Joint2D( * Container for method_bind pointers for Joint2D */ private object __method_bind { - val getBias: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint2D".cstr.ptr, - "get_bias".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bias" } - } - val getExcludeNodesFromCollision: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint2D".cstr.ptr, - "get_exclude_nodes_from_collision".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_exclude_nodes_from_collision" } - } - val getNodeA: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint2D".cstr.ptr, - "get_node_a".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_a" } - } - val getNodeB: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint2D".cstr.ptr, - "get_node_b".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_b" } - } - val setBias: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint2D".cstr.ptr, - "set_bias".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bias" } - } - val setExcludeNodesFromCollision: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint2D".cstr.ptr, - "set_exclude_nodes_from_collision".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_exclude_nodes_from_collision" } - } - val setNodeA: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint2D".cstr.ptr, - "set_node_a".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_node_a" } - } - val setNodeB: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint2D".cstr.ptr, - "set_node_b".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_node_b" } - }} + val getBias: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint2D".cstr.ptr, + "get_bias".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bias" } + } + } + + val getExcludeNodesFromCollision: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint2D".cstr.ptr, + "get_exclude_nodes_from_collision".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_exclude_nodes_from_collision" } + } + } + + val getNodeA: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint2D".cstr.ptr, + "get_node_a".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_a" } + } + } + + val getNodeB: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint2D".cstr.ptr, + "get_node_b".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_b" } + } + } + + val setBias: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint2D".cstr.ptr, + "set_bias".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bias" } + } + } + + val setExcludeNodesFromCollision: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint2D".cstr.ptr, + "set_exclude_nodes_from_collision".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_exclude_nodes_from_collision" } + } + } + + val setNodeA: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint2D".cstr.ptr, + "set_node_a".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_node_a" } + } + } + + val setNodeB: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Joint2D".cstr.ptr, + "set_node_b".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_node_b" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/KinematicBody.kt b/godot-kotlin/src/nativeGen/kotlin/godot/KinematicBody.kt index bbc31e3e..39f69f1e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/KinematicBody.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/KinematicBody.kt @@ -287,110 +287,140 @@ open class KinematicBody( * Container for method_bind pointers for KinematicBody */ private object __method_bind { - val getAxisLock: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, - "get_axis_lock".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_axis_lock" } - } - val getFloorNormal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, - "get_floor_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_floor_normal" } - } - val getFloorVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, - "get_floor_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_floor_velocity" } - } - val getSafeMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, - "get_safe_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_safe_margin" } - } - val getSlideCollision: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, - "get_slide_collision".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_slide_collision" } - } - val getSlideCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, - "get_slide_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_slide_count" } - } - val isOnCeiling: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, - "is_on_ceiling".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_on_ceiling" } - } - val isOnFloor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, - "is_on_floor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_on_floor" } - } - val isOnWall: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, - "is_on_wall".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_on_wall" } - } - val moveAndCollide: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, - "move_and_collide".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method move_and_collide" } - } - val moveAndSlide: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, - "move_and_slide".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method move_and_slide" } - } - val moveAndSlideWithSnap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, - "move_and_slide_with_snap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method move_and_slide_with_snap" } - } - val setAxisLock: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, - "set_axis_lock".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_axis_lock" } - } - val setSafeMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, - "set_safe_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_safe_margin" } - } - val testMove: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, - "test_move".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method test_move" } - }} + val getAxisLock: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, + "get_axis_lock".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_axis_lock" } + } + } + + val getFloorNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, + "get_floor_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_floor_normal" } + } + } + + val getFloorVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, + "get_floor_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_floor_velocity" } + } + } + + val getSafeMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, + "get_safe_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_safe_margin" } + } + } + + val getSlideCollision: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, + "get_slide_collision".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_slide_collision" } + } + } + + val getSlideCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, + "get_slide_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_slide_count" } + } + } + + val isOnCeiling: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, + "is_on_ceiling".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_on_ceiling" } + } + } + + val isOnFloor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, + "is_on_floor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_on_floor" } + } + } + + val isOnWall: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, + "is_on_wall".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_on_wall" } + } + } + + val moveAndCollide: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, + "move_and_collide".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method move_and_collide" } + } + } + + val moveAndSlide: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, + "move_and_slide".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method move_and_slide" } + } + } + + val moveAndSlideWithSnap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, + "move_and_slide_with_snap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method move_and_slide_with_snap" } + } + } + + val setAxisLock: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, + "set_axis_lock".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_axis_lock" } + } + } + + val setSafeMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, + "set_safe_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_safe_margin" } + } + } + + val testMove: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody".cstr.ptr, + "test_move".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method test_move" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/KinematicBody2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/KinematicBody2D.kt index 6756fda4..ceea8def 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/KinematicBody2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/KinematicBody2D.kt @@ -273,110 +273,140 @@ open class KinematicBody2D( * Container for method_bind pointers for KinematicBody2D */ private object __method_bind { - val getFloorNormal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, - "get_floor_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_floor_normal" } - } - val getFloorVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, - "get_floor_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_floor_velocity" } - } - val getSafeMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, - "get_safe_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_safe_margin" } - } - val getSlideCollision: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, - "get_slide_collision".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_slide_collision" } - } - val getSlideCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, - "get_slide_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_slide_count" } - } - val isOnCeiling: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, - "is_on_ceiling".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_on_ceiling" } - } - val isOnFloor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, - "is_on_floor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_on_floor" } - } - val isOnWall: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, - "is_on_wall".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_on_wall" } - } - val isSyncToPhysicsEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, - "is_sync_to_physics_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_sync_to_physics_enabled" } - } - val moveAndCollide: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, - "move_and_collide".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method move_and_collide" } - } - val moveAndSlide: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, - "move_and_slide".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method move_and_slide" } - } - val moveAndSlideWithSnap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, - "move_and_slide_with_snap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method move_and_slide_with_snap" } - } - val setSafeMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, - "set_safe_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_safe_margin" } - } - val setSyncToPhysics: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, - "set_sync_to_physics".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sync_to_physics" } - } - val testMove: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, - "test_move".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method test_move" } - }} + val getFloorNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, + "get_floor_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_floor_normal" } + } + } + + val getFloorVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, + "get_floor_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_floor_velocity" } + } + } + + val getSafeMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, + "get_safe_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_safe_margin" } + } + } + + val getSlideCollision: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, + "get_slide_collision".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_slide_collision" } + } + } + + val getSlideCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, + "get_slide_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_slide_count" } + } + } + + val isOnCeiling: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, + "is_on_ceiling".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_on_ceiling" } + } + } + + val isOnFloor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, + "is_on_floor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_on_floor" } + } + } + + val isOnWall: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, + "is_on_wall".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_on_wall" } + } + } + + val isSyncToPhysicsEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, + "is_sync_to_physics_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_sync_to_physics_enabled" } + } + } + + val moveAndCollide: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, + "move_and_collide".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method move_and_collide" } + } + } + + val moveAndSlide: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, + "move_and_slide".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method move_and_slide" } + } + } + + val moveAndSlideWithSnap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, + "move_and_slide_with_snap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method move_and_slide_with_snap" } + } + } + + val setSafeMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, + "set_safe_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_safe_margin" } + } + } + + val setSyncToPhysics: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, + "set_sync_to_physics".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sync_to_physics" } + } + } + + val testMove: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicBody2D".cstr.ptr, + "test_move".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method test_move" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/KinematicCollision.kt b/godot-kotlin/src/nativeGen/kotlin/godot/KinematicCollision.kt index 28787674..47bb922a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/KinematicCollision.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/KinematicCollision.kt @@ -227,82 +227,104 @@ open class KinematicCollision( * Container for method_bind pointers for KinematicCollision */ private object __method_bind { - val getCollider: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, - "get_collider".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider" } - } - val getColliderId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, - "get_collider_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider_id" } - } - val getColliderMetadata: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, - "get_collider_metadata".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider_metadata" } - } - val getColliderShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, - "get_collider_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider_shape" } - } - val getColliderShapeIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, - "get_collider_shape_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider_shape_index" } - } - val getColliderVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, - "get_collider_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider_velocity" } - } - val getLocalShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, - "get_local_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_local_shape" } - } - val getNormal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, - "get_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_normal" } - } - val getPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, - "get_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_position" } - } - val getRemainder: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, - "get_remainder".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_remainder" } - } - val getTravel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, - "get_travel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_travel" } - }} + val getCollider: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, + "get_collider".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider" } + } + } + + val getColliderId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, + "get_collider_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider_id" } + } + } + + val getColliderMetadata: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, + "get_collider_metadata".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider_metadata" } + } + } + + val getColliderShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, + "get_collider_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider_shape" } + } + } + + val getColliderShapeIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, + "get_collider_shape_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider_shape_index" } + } + } + + val getColliderVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, + "get_collider_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider_velocity" } + } + } + + val getLocalShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, + "get_local_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_local_shape" } + } + } + + val getNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, + "get_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_normal" } + } + } + + val getPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, + "get_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_position" } + } + } + + val getRemainder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, + "get_remainder".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_remainder" } + } + } + + val getTravel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision".cstr.ptr, + "get_travel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_travel" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/KinematicCollision2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/KinematicCollision2D.kt index 294fadc6..184d19ac 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/KinematicCollision2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/KinematicCollision2D.kt @@ -227,82 +227,104 @@ open class KinematicCollision2D( * Container for method_bind pointers for KinematicCollision2D */ private object __method_bind { - val getCollider: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, - "get_collider".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider" } - } - val getColliderId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, - "get_collider_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider_id" } - } - val getColliderMetadata: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, - "get_collider_metadata".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider_metadata" } - } - val getColliderShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, - "get_collider_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider_shape" } - } - val getColliderShapeIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, - "get_collider_shape_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider_shape_index" } - } - val getColliderVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, - "get_collider_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider_velocity" } - } - val getLocalShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, - "get_local_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_local_shape" } - } - val getNormal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, - "get_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_normal" } - } - val getPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, - "get_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_position" } - } - val getRemainder: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, - "get_remainder".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_remainder" } - } - val getTravel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, - "get_travel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_travel" } - }} + val getCollider: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, + "get_collider".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider" } + } + } + + val getColliderId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, + "get_collider_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider_id" } + } + } + + val getColliderMetadata: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, + "get_collider_metadata".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider_metadata" } + } + } + + val getColliderShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, + "get_collider_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider_shape" } + } + } + + val getColliderShapeIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, + "get_collider_shape_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider_shape_index" } + } + } + + val getColliderVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, + "get_collider_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider_velocity" } + } + } + + val getLocalShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, + "get_local_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_local_shape" } + } + } + + val getNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, + "get_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_normal" } + } + } + + val getPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, + "get_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_position" } + } + } + + val getRemainder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, + "get_remainder".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_remainder" } + } + } + + val getTravel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("KinematicCollision2D".cstr.ptr, + "get_travel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_travel" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Label.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Label.kt index c7e9bfb5..f0954d67 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Label.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Label.kt @@ -387,149 +387,197 @@ open class Label( * Container for method_bind pointers for Label */ private object __method_bind { - val getAlign: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "get_align".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_align" } - } - val getLineCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "get_line_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_line_count" } - } - val getLineHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "get_line_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_line_height" } - } - val getLinesSkipped: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "get_lines_skipped".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_lines_skipped" } - } - val getMaxLinesVisible: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "get_max_lines_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_max_lines_visible" } - } - val getPercentVisible: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "get_percent_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_percent_visible" } - } - val getText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "get_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_text" } - } - val getTotalCharacterCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "get_total_character_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_total_character_count" } - } - val getValign: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "get_valign".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_valign" } - } - val getVisibleCharacters: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "get_visible_characters".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_visible_characters" } - } - val getVisibleLineCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "get_visible_line_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_visible_line_count" } - } - val hasAutowrap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "has_autowrap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_autowrap" } - } - val isClippingText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "is_clipping_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_clipping_text" } - } - val isUppercase: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "is_uppercase".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_uppercase" } - } - val setAlign: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "set_align".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_align" } - } - val setAutowrap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "set_autowrap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_autowrap" } - } - val setClipText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "set_clip_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_clip_text" } - } - val setLinesSkipped: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "set_lines_skipped".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_lines_skipped" } - } - val setMaxLinesVisible: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "set_max_lines_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_max_lines_visible" } - } - val setPercentVisible: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "set_percent_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_percent_visible" } - } - val setText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "set_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_text" } - } - val setUppercase: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "set_uppercase".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_uppercase" } - } - val setValign: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "set_valign".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_valign" } - } - val setVisibleCharacters: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, - "set_visible_characters".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_visible_characters" } - }} + val getAlign: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "get_align".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_align" } + } + } + + val getLineCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "get_line_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_line_count" } + } + } + + val getLineHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "get_line_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_line_height" } + } + } + + val getLinesSkipped: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "get_lines_skipped".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_lines_skipped" } + } + } + + val getMaxLinesVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "get_max_lines_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_max_lines_visible" } + } + } + + val getPercentVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "get_percent_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_percent_visible" } + } + } + + val getText: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "get_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_text" } + } + } + + val getTotalCharacterCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "get_total_character_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_total_character_count" } + } + } + + val getValign: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "get_valign".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_valign" } + } + } + + val getVisibleCharacters: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "get_visible_characters".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_visible_characters" } + } + } + + val getVisibleLineCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "get_visible_line_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_visible_line_count" } + } + } + + val hasAutowrap: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "has_autowrap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_autowrap" } + } + } + + val isClippingText: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "is_clipping_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_clipping_text" } + } + } + + val isUppercase: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "is_uppercase".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_uppercase" } + } + } + + val setAlign: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "set_align".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_align" } + } + } + + val setAutowrap: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "set_autowrap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_autowrap" } + } + } + + val setClipText: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "set_clip_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_clip_text" } + } + } + + val setLinesSkipped: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "set_lines_skipped".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_lines_skipped" } + } + } + + val setMaxLinesVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "set_max_lines_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_max_lines_visible" } + } + } + + val setPercentVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "set_percent_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_percent_visible" } + } + } + + val setText: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "set_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_text" } + } + } + + val setUppercase: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "set_uppercase".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_uppercase" } + } + } + + val setValign: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "set_valign".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_valign" } + } + } + + val setVisibleCharacters: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Label".cstr.ptr, + "set_visible_characters".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_visible_characters" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/LargeTexture.kt b/godot-kotlin/src/nativeGen/kotlin/godot/LargeTexture.kt index d78d725d..67dec1b9 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/LargeTexture.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/LargeTexture.kt @@ -137,61 +137,77 @@ open class LargeTexture( * Container for method_bind pointers for LargeTexture */ private object __method_bind { - val addPiece: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LargeTexture".cstr.ptr, - "add_piece".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_piece" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LargeTexture".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val getPieceCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LargeTexture".cstr.ptr, - "get_piece_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_piece_count" } - } - val getPieceOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LargeTexture".cstr.ptr, - "get_piece_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_piece_offset" } - } - val getPieceTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LargeTexture".cstr.ptr, - "get_piece_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_piece_texture" } - } - val setPieceOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LargeTexture".cstr.ptr, - "set_piece_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_piece_offset" } - } - val setPieceTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LargeTexture".cstr.ptr, - "set_piece_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_piece_texture" } - } - val setSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LargeTexture".cstr.ptr, - "set_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_size" } - }} + val addPiece: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LargeTexture".cstr.ptr, + "add_piece".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_piece" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LargeTexture".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val getPieceCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LargeTexture".cstr.ptr, + "get_piece_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_piece_count" } + } + } + + val getPieceOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LargeTexture".cstr.ptr, + "get_piece_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_piece_offset" } + } + } + + val getPieceTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LargeTexture".cstr.ptr, + "get_piece_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_piece_texture" } + } + } + + val setPieceOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LargeTexture".cstr.ptr, + "set_piece_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_piece_offset" } + } + } + + val setPieceTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LargeTexture".cstr.ptr, + "set_piece_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_piece_texture" } + } + } + + val setSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LargeTexture".cstr.ptr, + "set_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_size" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Light.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Light.kt index d1dbecf5..c02fabc8 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Light.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Light.kt @@ -394,113 +394,149 @@ open class Light( * Container for method_bind pointers for Light */ private object __method_bind { - val getBakeMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, - "get_bake_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bake_mode" } - } - val getColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, - "get_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_color" } - } - val getCullMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, - "get_cull_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cull_mask" } - } - val getParam: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, - "get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_param" } - } - val getShadowColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, - "get_shadow_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shadow_color" } - } - val getShadowReverseCullFace: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, - "get_shadow_reverse_cull_face".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shadow_reverse_cull_face" } - } - val hasShadow: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, - "has_shadow".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_shadow" } - } - val isEditorOnly: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, - "is_editor_only".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_editor_only" } - } - val isNegative: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, - "is_negative".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_negative" } - } - val setBakeMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, - "set_bake_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bake_mode" } - } - val setColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, - "set_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_color" } - } - val setCullMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, - "set_cull_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cull_mask" } - } - val setEditorOnly: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, - "set_editor_only".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_editor_only" } - } - val setNegative: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, - "set_negative".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_negative" } - } - val setParam: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, - "set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_param" } - } - val setShadow: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, - "set_shadow".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shadow" } - } - val setShadowColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, - "set_shadow_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shadow_color" } - } - val setShadowReverseCullFace: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, - "set_shadow_reverse_cull_face".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shadow_reverse_cull_face" } - }} + val getBakeMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, + "get_bake_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bake_mode" } + } + } + + val getColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, + "get_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_color" } + } + } + + val getCullMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, + "get_cull_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cull_mask" } + } + } + + val getParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, + "get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_param" } + } + } + + val getShadowColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, + "get_shadow_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shadow_color" } + } + } + + val getShadowReverseCullFace: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, + "get_shadow_reverse_cull_face".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shadow_reverse_cull_face" } + } + } + + val hasShadow: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, + "has_shadow".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_shadow" } + } + } + + val isEditorOnly: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, + "is_editor_only".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_editor_only" } + } + } + + val isNegative: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, + "is_negative".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_negative" } + } + } + + val setBakeMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, + "set_bake_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bake_mode" } + } + } + + val setColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, + "set_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_color" } + } + } + + val setCullMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, + "set_cull_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cull_mask" } + } + } + + val setEditorOnly: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, + "set_editor_only".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_editor_only" } + } + } + + val setNegative: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, + "set_negative".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_negative" } + } + } + + val setParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, + "set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_param" } + } + } + + val setShadow: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, + "set_shadow".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shadow" } + } + } + + val setShadowColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, + "set_shadow_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shadow_color" } + } + } + + val setShadowReverseCullFace: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light".cstr.ptr, + "set_shadow_reverse_cull_face".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shadow_reverse_cull_face" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Light2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Light2D.kt index 5ee7f372..8b9d83b6 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Light2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Light2D.kt @@ -660,257 +660,383 @@ open class Light2D( * Container for method_bind pointers for Light2D */ private object __method_bind { - val getColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "get_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_color" } - } - val getEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "get_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_energy" } - } - val getHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "get_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_height" } - } - val getItemCullMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "get_item_cull_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_cull_mask" } - } - val getItemShadowCullMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "get_item_shadow_cull_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_shadow_cull_mask" } - } - val getLayerRangeMax: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "get_layer_range_max".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_layer_range_max" } - } - val getLayerRangeMin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "get_layer_range_min".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_layer_range_min" } - } - val getMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "get_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mode" } - } - val getShadowBufferSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "get_shadow_buffer_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shadow_buffer_size" } - } - val getShadowColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "get_shadow_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shadow_color" } - } - val getShadowFilter: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "get_shadow_filter".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shadow_filter" } - } - val getShadowGradientLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "get_shadow_gradient_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shadow_gradient_length" } - } - val getShadowSmooth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "get_shadow_smooth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shadow_smooth" } - } - val getTexture: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "get_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture" } - } - val getTextureOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "get_texture_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture_offset" } - } - val getTextureScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "get_texture_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture_scale" } - } - val getZRangeMax: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "get_z_range_max".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_z_range_max" } - } - val getZRangeMin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "get_z_range_min".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_z_range_min" } - } - val isEditorOnly: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "is_editor_only".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_editor_only" } - } - val isEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "is_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_enabled" } - } - val isShadowEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "is_shadow_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_shadow_enabled" } - } - val setColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_color" } - } - val setEditorOnly: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_editor_only".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_editor_only" } - } - val setEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_enabled" } - } - val setEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_energy" } - } - val setHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_height" } - } - val setItemCullMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_item_cull_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_cull_mask" } - } - val setItemShadowCullMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_item_shadow_cull_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_shadow_cull_mask" } - } - val setLayerRangeMax: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_layer_range_max".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_layer_range_max" } - } - val setLayerRangeMin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_layer_range_min".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_layer_range_min" } - } - val setMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mode" } - } - val setShadowBufferSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_shadow_buffer_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shadow_buffer_size" } - } - val setShadowColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_shadow_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shadow_color" } - } - val setShadowEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_shadow_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shadow_enabled" } - } - val setShadowFilter: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_shadow_filter".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shadow_filter" } - } - val setShadowGradientLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_shadow_gradient_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shadow_gradient_length" } - } - val setShadowSmooth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_shadow_smooth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shadow_smooth" } - } - val setTexture: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture" } - } - val setTextureOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_texture_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture_offset" } - } - val setTextureScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_texture_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture_scale" } - } - val setZRangeMax: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_z_range_max".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_z_range_max" } - } - val setZRangeMin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, - "set_z_range_min".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_z_range_min" } - }} + val getColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "get_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_color" } + } + } + + val getEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "get_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_energy" } + } + } + + val getHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "get_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_height" } + } + } + + val getItemCullMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "get_item_cull_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_cull_mask" } + } + } + + val getItemShadowCullMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "get_item_shadow_cull_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_shadow_cull_mask" } + } + } + + val getLayerRangeMax: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "get_layer_range_max".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_layer_range_max" } + } + } + + val getLayerRangeMin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "get_layer_range_min".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_layer_range_min" } + } + } + + val getMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "get_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mode" } + } + } + + val getShadowBufferSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "get_shadow_buffer_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shadow_buffer_size" } + } + } + + val getShadowColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "get_shadow_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shadow_color" } + } + } + + val getShadowFilter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "get_shadow_filter".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shadow_filter" } + } + } + + val getShadowGradientLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "get_shadow_gradient_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shadow_gradient_length" } + } + } + + val getShadowSmooth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "get_shadow_smooth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shadow_smooth" } + } + } + + val getTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "get_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture" } + } + } + + val getTextureOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "get_texture_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture_offset" } + } + } + + val getTextureScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "get_texture_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture_scale" } + } + } + + val getZRangeMax: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "get_z_range_max".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_z_range_max" } + } + } + + val getZRangeMin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "get_z_range_min".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_z_range_min" } + } + } + + val isEditorOnly: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "is_editor_only".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_editor_only" } + } + } + + val isEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "is_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_enabled" } + } + } + + val isShadowEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "is_shadow_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_shadow_enabled" } + } + } + + val setColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_color" } + } + } + + val setEditorOnly: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_editor_only".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_editor_only" } + } + } + + val setEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_enabled" } + } + } + + val setEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_energy" } + } + } + + val setHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_height" } + } + } + + val setItemCullMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_item_cull_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_cull_mask" } + } + } + + val setItemShadowCullMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_item_shadow_cull_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_shadow_cull_mask" } + } + } + + val setLayerRangeMax: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_layer_range_max".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_layer_range_max" } + } + } + + val setLayerRangeMin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_layer_range_min".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_layer_range_min" } + } + } + + val setMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mode" } + } + } + + val setShadowBufferSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_shadow_buffer_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shadow_buffer_size" } + } + } + + val setShadowColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_shadow_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shadow_color" } + } + } + + val setShadowEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_shadow_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shadow_enabled" } + } + } + + val setShadowFilter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_shadow_filter".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shadow_filter" } + } + } + + val setShadowGradientLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_shadow_gradient_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shadow_gradient_length" } + } + } + + val setShadowSmooth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_shadow_smooth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shadow_smooth" } + } + } + + val setTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture" } + } + } + + val setTextureOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_texture_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture_offset" } + } + } + + val setTextureScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_texture_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture_scale" } + } + } + + val setZRangeMax: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_z_range_max".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_z_range_max" } + } + } + + val setZRangeMin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Light2D".cstr.ptr, + "set_z_range_min".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_z_range_min" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/LightOccluder2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/LightOccluder2D.kt index 51283d50..505e87b0 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/LightOccluder2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/LightOccluder2D.kt @@ -97,33 +97,41 @@ open class LightOccluder2D( * Container for method_bind pointers for LightOccluder2D */ private object __method_bind { - val getOccluderLightMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LightOccluder2D".cstr.ptr, - "get_occluder_light_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_occluder_light_mask" } - } - val getOccluderPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LightOccluder2D".cstr.ptr, - "get_occluder_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_occluder_polygon" } - } - val setOccluderLightMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LightOccluder2D".cstr.ptr, - "set_occluder_light_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_occluder_light_mask" } - } - val setOccluderPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LightOccluder2D".cstr.ptr, - "set_occluder_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_occluder_polygon" } - }} + val getOccluderLightMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LightOccluder2D".cstr.ptr, + "get_occluder_light_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_occluder_light_mask" } + } + } + + val getOccluderPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LightOccluder2D".cstr.ptr, + "get_occluder_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_occluder_polygon" } + } + } + + val setOccluderLightMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LightOccluder2D".cstr.ptr, + "set_occluder_light_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_occluder_light_mask" } + } + } + + val setOccluderPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LightOccluder2D".cstr.ptr, + "set_occluder_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_occluder_polygon" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Line2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Line2D.kt index 52bda28e..9edf268f 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Line2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Line2D.kt @@ -531,197 +531,261 @@ open class Line2D( * Container for method_bind pointers for Line2D */ private object __method_bind { - val addPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "add_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_point" } - } - val clearPoints: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "clear_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_points" } - } - val getAntialiased: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "get_antialiased".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_antialiased" } - } - val getBeginCapMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "get_begin_cap_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_begin_cap_mode" } - } - val getCurve: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "get_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_curve" } - } - val getDefaultColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "get_default_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_default_color" } - } - val getEndCapMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "get_end_cap_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_end_cap_mode" } - } - val getGradient: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "get_gradient".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gradient" } - } - val getJointMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "get_joint_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_joint_mode" } - } - val getPointCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "get_point_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_count" } - } - val getPointPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "get_point_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_position" } - } - val getPoints: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "get_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_points" } - } - val getRoundPrecision: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "get_round_precision".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_round_precision" } - } - val getSharpLimit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "get_sharp_limit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sharp_limit" } - } - val getTexture: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "get_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture" } - } - val getTextureMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "get_texture_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture_mode" } - } - val getWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "get_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_width" } - } - val removePoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "remove_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_point" } - } - val setAntialiased: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "set_antialiased".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_antialiased" } - } - val setBeginCapMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "set_begin_cap_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_begin_cap_mode" } - } - val setCurve: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "set_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_curve" } - } - val setDefaultColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "set_default_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_default_color" } - } - val setEndCapMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "set_end_cap_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_end_cap_mode" } - } - val setGradient: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "set_gradient".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_gradient" } - } - val setJointMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "set_joint_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_joint_mode" } - } - val setPointPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "set_point_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_position" } - } - val setPoints: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "set_points".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_points" } - } - val setRoundPrecision: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "set_round_precision".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_round_precision" } - } - val setSharpLimit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "set_sharp_limit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sharp_limit" } - } - val setTexture: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "set_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture" } - } - val setTextureMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "set_texture_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture_mode" } - } - val setWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, - "set_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_width" } - }} + val addPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "add_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_point" } + } + } + + val clearPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "clear_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_points" } + } + } + + val getAntialiased: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "get_antialiased".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_antialiased" } + } + } + + val getBeginCapMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "get_begin_cap_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_begin_cap_mode" } + } + } + + val getCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "get_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_curve" } + } + } + + val getDefaultColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "get_default_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_default_color" } + } + } + + val getEndCapMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "get_end_cap_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_end_cap_mode" } + } + } + + val getGradient: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "get_gradient".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gradient" } + } + } + + val getJointMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "get_joint_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_joint_mode" } + } + } + + val getPointCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "get_point_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_count" } + } + } + + val getPointPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "get_point_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_position" } + } + } + + val getPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "get_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_points" } + } + } + + val getRoundPrecision: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "get_round_precision".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_round_precision" } + } + } + + val getSharpLimit: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "get_sharp_limit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sharp_limit" } + } + } + + val getTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "get_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture" } + } + } + + val getTextureMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "get_texture_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture_mode" } + } + } + + val getWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "get_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_width" } + } + } + + val removePoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "remove_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_point" } + } + } + + val setAntialiased: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "set_antialiased".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_antialiased" } + } + } + + val setBeginCapMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "set_begin_cap_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_begin_cap_mode" } + } + } + + val setCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "set_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_curve" } + } + } + + val setDefaultColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "set_default_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_default_color" } + } + } + + val setEndCapMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "set_end_cap_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_end_cap_mode" } + } + } + + val setGradient: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "set_gradient".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_gradient" } + } + } + + val setJointMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "set_joint_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_joint_mode" } + } + } + + val setPointPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "set_point_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_position" } + } + } + + val setPoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "set_points".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_points" } + } + } + + val setRoundPrecision: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "set_round_precision".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_round_precision" } + } + } + + val setSharpLimit: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "set_sharp_limit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sharp_limit" } + } + } + + val setTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "set_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture" } + } + } + + val setTextureMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "set_texture_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture_mode" } + } + } + + val setWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Line2D".cstr.ptr, + "set_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_width" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/LineEdit.kt b/godot-kotlin/src/nativeGen/kotlin/godot/LineEdit.kt index 0f2b4d46..ffa55c63 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/LineEdit.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/LineEdit.kt @@ -618,251 +618,374 @@ open class LineEdit( * Container for method_bind pointers for LineEdit */ private object __method_bind { - val appendAtCursor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "append_at_cursor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method append_at_cursor" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val cursorGetBlinkEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "cursor_get_blink_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cursor_get_blink_enabled" } - } - val cursorGetBlinkSpeed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "cursor_get_blink_speed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cursor_get_blink_speed" } - } - val cursorSetBlinkEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "cursor_set_blink_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cursor_set_blink_enabled" } - } - val cursorSetBlinkSpeed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "cursor_set_blink_speed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cursor_set_blink_speed" } - } - val deselect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "deselect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method deselect" } - } - val getAlign: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "get_align".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_align" } - } - val getCursorPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "get_cursor_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cursor_position" } - } - val getExpandToTextLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "get_expand_to_text_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_expand_to_text_length" } - } - val getMaxLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "get_max_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_max_length" } - } - val getMenu: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "get_menu".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_menu" } - } - val getPlaceholder: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "get_placeholder".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_placeholder" } - } - val getPlaceholderAlpha: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "get_placeholder_alpha".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_placeholder_alpha" } - } - val getRightIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "get_right_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_right_icon" } - } - val getSecretCharacter: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "get_secret_character".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_secret_character" } - } - val getText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "get_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_text" } - } - val isClearButtonEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "is_clear_button_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_clear_button_enabled" } - } - val isContextMenuEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "is_context_menu_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_context_menu_enabled" } - } - val isEditable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "is_editable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_editable" } - } - val isSecret: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "is_secret".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_secret" } - } - val isSelectingEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "is_selecting_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_selecting_enabled" } - } - val isShortcutKeysEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "is_shortcut_keys_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_shortcut_keys_enabled" } - } - val menuOption: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "menu_option".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method menu_option" } - } - val select: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "select".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method select" } - } - val selectAll: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "select_all".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method select_all" } - } - val setAlign: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "set_align".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_align" } - } - val setClearButtonEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "set_clear_button_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_clear_button_enabled" } - } - val setContextMenuEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "set_context_menu_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_context_menu_enabled" } - } - val setCursorPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "set_cursor_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cursor_position" } - } - val setEditable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "set_editable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_editable" } - } - val setExpandToTextLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "set_expand_to_text_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_expand_to_text_length" } - } - val setMaxLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "set_max_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_max_length" } - } - val setPlaceholder: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "set_placeholder".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_placeholder" } - } - val setPlaceholderAlpha: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "set_placeholder_alpha".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_placeholder_alpha" } - } - val setRightIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "set_right_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_right_icon" } - } - val setSecret: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "set_secret".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_secret" } - } - val setSecretCharacter: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "set_secret_character".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_secret_character" } - } - val setSelectingEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "set_selecting_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_selecting_enabled" } - } - val setShortcutKeysEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "set_shortcut_keys_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shortcut_keys_enabled" } - } - val setText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, - "set_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_text" } - }} + val appendAtCursor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "append_at_cursor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method append_at_cursor" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val cursorGetBlinkEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "cursor_get_blink_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cursor_get_blink_enabled" } + } + } + + val cursorGetBlinkSpeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "cursor_get_blink_speed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cursor_get_blink_speed" } + } + } + + val cursorSetBlinkEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "cursor_set_blink_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cursor_set_blink_enabled" } + } + } + + val cursorSetBlinkSpeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "cursor_set_blink_speed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cursor_set_blink_speed" } + } + } + + val deselect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "deselect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method deselect" } + } + } + + val getAlign: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "get_align".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_align" } + } + } + + val getCursorPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "get_cursor_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cursor_position" } + } + } + + val getExpandToTextLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "get_expand_to_text_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_expand_to_text_length" } + } + } + + val getMaxLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "get_max_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_max_length" } + } + } + + val getMenu: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "get_menu".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_menu" } + } + } + + val getPlaceholder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "get_placeholder".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_placeholder" } + } + } + + val getPlaceholderAlpha: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "get_placeholder_alpha".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_placeholder_alpha" } + } + } + + val getRightIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "get_right_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_right_icon" } + } + } + + val getSecretCharacter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "get_secret_character".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_secret_character" } + } + } + + val getText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "get_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_text" } + } + } + + val isClearButtonEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "is_clear_button_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_clear_button_enabled" } + } + } + + val isContextMenuEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "is_context_menu_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_context_menu_enabled" } + } + } + + val isEditable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "is_editable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_editable" } + } + } + + val isSecret: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "is_secret".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_secret" } + } + } + + val isSelectingEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "is_selecting_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_selecting_enabled" } + } + } + + val isShortcutKeysEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "is_shortcut_keys_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_shortcut_keys_enabled" } + } + } + + val menuOption: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "menu_option".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method menu_option" } + } + } + + val select: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "select".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method select" } + } + } + + val selectAll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "select_all".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method select_all" } + } + } + + val setAlign: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "set_align".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_align" } + } + } + + val setClearButtonEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "set_clear_button_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_clear_button_enabled" } + } + } + + val setContextMenuEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "set_context_menu_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_context_menu_enabled" } + } + } + + val setCursorPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "set_cursor_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cursor_position" } + } + } + + val setEditable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "set_editable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_editable" } + } + } + + val setExpandToTextLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "set_expand_to_text_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_expand_to_text_length" } + } + } + + val setMaxLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "set_max_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_max_length" } + } + } + + val setPlaceholder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "set_placeholder".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_placeholder" } + } + } + + val setPlaceholderAlpha: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "set_placeholder_alpha".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_placeholder_alpha" } + } + } + + val setRightIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "set_right_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_right_icon" } + } + } + + val setSecret: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "set_secret".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_secret" } + } + } + + val setSecretCharacter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "set_secret_character".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_secret_character" } + } + } + + val setSelectingEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "set_selecting_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_selecting_enabled" } + } + } + + val setShortcutKeysEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "set_shortcut_keys_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shortcut_keys_enabled" } + } + } + + val setText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineEdit".cstr.ptr, + "set_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_text" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/LineShape2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/LineShape2D.kt index 25a142ac..a6c52fb4 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/LineShape2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/LineShape2D.kt @@ -110,33 +110,41 @@ open class LineShape2D( * Container for method_bind pointers for LineShape2D */ private object __method_bind { - val getD: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineShape2D".cstr.ptr, - "get_d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_d" } - } - val getNormal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineShape2D".cstr.ptr, - "get_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_normal" } - } - val setD: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineShape2D".cstr.ptr, - "set_d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_d" } - } - val setNormal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineShape2D".cstr.ptr, - "set_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_normal" } - }} + val getD: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineShape2D".cstr.ptr, + "get_d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_d" } + } + } + + val getNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineShape2D".cstr.ptr, + "get_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_normal" } + } + } + + val setD: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineShape2D".cstr.ptr, + "set_d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_d" } + } + } + + val setNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LineShape2D".cstr.ptr, + "set_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_normal" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/LinkButton.kt b/godot-kotlin/src/nativeGen/kotlin/godot/LinkButton.kt index f5c332ff..05fc22c1 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/LinkButton.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/LinkButton.kt @@ -120,29 +120,41 @@ open class LinkButton( * Container for method_bind pointers for LinkButton */ private object __method_bind { - val getText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LinkButton".cstr.ptr, - "get_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_text" } - } - val getUnderlineMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LinkButton".cstr.ptr, - "get_underline_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_underline_mode" } - } - val setText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LinkButton".cstr.ptr, - "set_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_text" } - } - val setUnderlineMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LinkButton".cstr.ptr, - "set_underline_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_underline_mode" } - }} + val getText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LinkButton".cstr.ptr, + "get_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_text" } + } + } + + val getUnderlineMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LinkButton".cstr.ptr, + "get_underline_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_underline_mode" } + } + } + + val setText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LinkButton".cstr.ptr, + "set_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_text" } + } + } + + val setUnderlineMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("LinkButton".cstr.ptr, + "set_underline_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_underline_mode" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Listener.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Listener.kt index 52c5d2af..0d11b4c8 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Listener.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Listener.kt @@ -84,29 +84,41 @@ open class Listener( * Container for method_bind pointers for Listener */ private object __method_bind { - val clearCurrent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Listener".cstr.ptr, - "clear_current".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_current" } - } - val getListenerTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Listener".cstr.ptr, - "get_listener_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_listener_transform" } - } - val isCurrent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Listener".cstr.ptr, - "is_current".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_current" } - } - val makeCurrent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Listener".cstr.ptr, - "make_current".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method make_current" } - }} + val clearCurrent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Listener".cstr.ptr, + "clear_current".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_current" } + } + } + + val getListenerTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Listener".cstr.ptr, + "get_listener_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_listener_transform" } + } + } + + val isCurrent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Listener".cstr.ptr, + "is_current".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_current" } + } + } + + val makeCurrent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Listener".cstr.ptr, + "make_current".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method make_current" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/MainLoop.kt b/godot-kotlin/src/nativeGen/kotlin/godot/MainLoop.kt index c64ad5d8..317d1cd8 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/MainLoop.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/MainLoop.kt @@ -165,41 +165,59 @@ open class MainLoop( * Container for method_bind pointers for MainLoop */ private object __method_bind { - val finish: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MainLoop".cstr.ptr, - "finish".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method finish" } - } - val idle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MainLoop".cstr.ptr, - "idle".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method idle" } - } - val init: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MainLoop".cstr.ptr, - "init".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method init" } - } - val inputEvent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MainLoop".cstr.ptr, - "input_event".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method input_event" } - } - val inputText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MainLoop".cstr.ptr, - "input_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method input_text" } - } - val iteration: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MainLoop".cstr.ptr, - "iteration".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method iteration" } - }} + val finish: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MainLoop".cstr.ptr, + "finish".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method finish" } + } + } + + val idle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MainLoop".cstr.ptr, + "idle".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method idle" } + } + } + + val init: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MainLoop".cstr.ptr, + "init".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method init" } + } + } + + val inputEvent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MainLoop".cstr.ptr, + "input_event".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method input_event" } + } + } + + val inputText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MainLoop".cstr.ptr, + "input_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method input_text" } + } + } + + val iteration: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MainLoop".cstr.ptr, + "iteration".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method iteration" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Marshalls.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Marshalls.kt index 75e310df..30ec5cad 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Marshalls.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Marshalls.kt @@ -109,42 +109,60 @@ open class MarshallsInternal( * Container for method_bind pointers for Marshalls */ private object __method_bind { - val base64ToRaw: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Marshalls".cstr.ptr, - "base64_to_raw".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method base64_to_raw" } - } - val base64ToUtf8: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Marshalls".cstr.ptr, - "base64_to_utf8".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method base64_to_utf8" } - } - val base64ToVariant: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Marshalls".cstr.ptr, - "base64_to_variant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method base64_to_variant" } - } - val rawToBase64: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Marshalls".cstr.ptr, - "raw_to_base64".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method raw_to_base64" } - } - val utf8ToBase64: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Marshalls".cstr.ptr, - "utf8_to_base64".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method utf8_to_base64" } - } - val variantToBase64: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Marshalls".cstr.ptr, - "variant_to_base64".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method variant_to_base64" } - }} + val base64ToRaw: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Marshalls".cstr.ptr, + "base64_to_raw".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method base64_to_raw" } + } + } + + val base64ToUtf8: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Marshalls".cstr.ptr, + "base64_to_utf8".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method base64_to_utf8" } + } + } + + val base64ToVariant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Marshalls".cstr.ptr, + "base64_to_variant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method base64_to_variant" } + } + } + + val rawToBase64: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Marshalls".cstr.ptr, + "raw_to_base64".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method raw_to_base64" } + } + } + + val utf8ToBase64: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Marshalls".cstr.ptr, + "utf8_to_base64".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method utf8_to_base64" } + } + } + + val variantToBase64: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Marshalls".cstr.ptr, + "variant_to_base64".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method variant_to_base64" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Material.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Material.kt index a1a4cc88..8b3146eb 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Material.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Material.kt @@ -98,29 +98,41 @@ open class Material( * Container for method_bind pointers for Material */ private object __method_bind { - val getNextPass: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Material".cstr.ptr, - "get_next_pass".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_next_pass" } - } - val getRenderPriority: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Material".cstr.ptr, - "get_render_priority".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_render_priority" } - } - val setNextPass: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Material".cstr.ptr, - "set_next_pass".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_next_pass" } - } - val setRenderPriority: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Material".cstr.ptr, - "set_render_priority".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_render_priority" } - }} + val getNextPass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Material".cstr.ptr, + "get_next_pass".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_next_pass" } + } + } + + val getRenderPriority: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Material".cstr.ptr, + "get_render_priority".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_render_priority" } + } + } + + val setNextPass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Material".cstr.ptr, + "set_next_pass".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_next_pass" } + } + } + + val setRenderPriority: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Material".cstr.ptr, + "set_render_priority".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_render_priority" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/MenuButton.kt b/godot-kotlin/src/nativeGen/kotlin/godot/MenuButton.kt index fddc2e6b..1ed1df32 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/MenuButton.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/MenuButton.kt @@ -105,29 +105,41 @@ open class MenuButton( * Container for method_bind pointers for MenuButton */ private object __method_bind { - val getPopup: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MenuButton".cstr.ptr, - "get_popup".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_popup" } - } - val isSwitchOnHover: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MenuButton".cstr.ptr, - "is_switch_on_hover".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_switch_on_hover" } - } - val setDisableShortcuts: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MenuButton".cstr.ptr, - "set_disable_shortcuts".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_disable_shortcuts" } - } - val setSwitchOnHover: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MenuButton".cstr.ptr, - "set_switch_on_hover".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_switch_on_hover" } - }} + val getPopup: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MenuButton".cstr.ptr, + "get_popup".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_popup" } + } + } + + val isSwitchOnHover: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MenuButton".cstr.ptr, + "is_switch_on_hover".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_switch_on_hover" } + } + } + + val setDisableShortcuts: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MenuButton".cstr.ptr, + "set_disable_shortcuts".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_disable_shortcuts" } + } + } + + val setSwitchOnHover: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MenuButton".cstr.ptr, + "set_switch_on_hover".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_switch_on_hover" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Mesh.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Mesh.kt index 5f3c8e33..e93be747 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Mesh.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Mesh.kt @@ -348,83 +348,110 @@ open class Mesh( * Container for method_bind pointers for Mesh */ private object __method_bind { - val createConvexShape: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, - "create_convex_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_convex_shape" } - } - val createOutline: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, - "create_outline".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_outline" } - } - val createTrimeshShape: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, - "create_trimesh_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_trimesh_shape" } - } - val generateTriangleMesh: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, - "generate_triangle_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method generate_triangle_mesh" } - } - val getAabb: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, - "get_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_aabb" } - } - val getFaces: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, - "get_faces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_faces" } - } - val getLightmapSizeHint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, - "get_lightmap_size_hint".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_lightmap_size_hint" } - } - val getSurfaceCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, - "get_surface_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_surface_count" } - } - val setLightmapSizeHint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, - "set_lightmap_size_hint".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_lightmap_size_hint" } - } - val surfaceGetArrays: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, - "surface_get_arrays".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method surface_get_arrays" } - } - val surfaceGetBlendShapeArrays: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, - "surface_get_blend_shape_arrays".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method surface_get_blend_shape_arrays" } - } - val surfaceGetMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, - "surface_get_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method surface_get_material" } - } - val surfaceSetMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, - "surface_set_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method surface_set_material" } - }} + val createConvexShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, + "create_convex_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_convex_shape" } + } + } + + val createOutline: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, + "create_outline".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_outline" } + } + } + + val createTrimeshShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, + "create_trimesh_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_trimesh_shape" } + } + } + + val generateTriangleMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, + "generate_triangle_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method generate_triangle_mesh" } + } + } + + val getAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, + "get_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_aabb" } + } + } + + val getFaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, + "get_faces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_faces" } + } + } + + val getLightmapSizeHint: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, + "get_lightmap_size_hint".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_lightmap_size_hint" } + } + } + + val getSurfaceCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, + "get_surface_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_surface_count" } + } + } + + val setLightmapSizeHint: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, + "set_lightmap_size_hint".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_lightmap_size_hint" } + } + } + + val surfaceGetArrays: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, + "surface_get_arrays".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method surface_get_arrays" } + } + } + + val surfaceGetBlendShapeArrays: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, + "surface_get_blend_shape_arrays".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method surface_get_blend_shape_arrays" + } + } + } + + val surfaceGetMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, + "surface_get_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method surface_get_material" } + } + } + + val surfaceSetMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Mesh".cstr.ptr, + "surface_set_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method surface_set_material" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/MeshDataTool.kt b/godot-kotlin/src/nativeGen/kotlin/godot/MeshDataTool.kt index d93ff1ba..17776709 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/MeshDataTool.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/MeshDataTool.kt @@ -458,271 +458,347 @@ open class MeshDataTool( * Container for method_bind pointers for MeshDataTool */ private object __method_bind { - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val commitToSurface: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "commit_to_surface".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method commit_to_surface" } - } - val createFromSurface: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "create_from_surface".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_from_surface" } - } - val getEdgeCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_edge_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_edge_count" } - } - val getEdgeFaces: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_edge_faces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_edge_faces" } - } - val getEdgeMeta: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_edge_meta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_edge_meta" } - } - val getEdgeVertex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_edge_vertex".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_edge_vertex" } - } - val getFaceCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_face_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_face_count" } - } - val getFaceEdge: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_face_edge".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_face_edge" } - } - val getFaceMeta: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_face_meta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_face_meta" } - } - val getFaceNormal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_face_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_face_normal" } - } - val getFaceVertex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_face_vertex".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_face_vertex" } - } - val getFormat: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_format".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_format" } - } - val getMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_material" } - } - val getVertex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_vertex".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vertex" } - } - val getVertexBones: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_vertex_bones".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vertex_bones" } - } - val getVertexColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_vertex_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vertex_color" } - } - val getVertexCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_vertex_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vertex_count" } - } - val getVertexEdges: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_vertex_edges".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vertex_edges" } - } - val getVertexFaces: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_vertex_faces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vertex_faces" } - } - val getVertexMeta: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_vertex_meta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vertex_meta" } - } - val getVertexNormal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_vertex_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vertex_normal" } - } - val getVertexTangent: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_vertex_tangent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vertex_tangent" } - } - val getVertexUv: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_vertex_uv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vertex_uv" } - } - val getVertexUv2: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_vertex_uv2".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vertex_uv2" } - } - val getVertexWeights: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "get_vertex_weights".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vertex_weights" } - } - val setEdgeMeta: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "set_edge_meta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_edge_meta" } - } - val setFaceMeta: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "set_face_meta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_face_meta" } - } - val setMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "set_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_material" } - } - val setVertex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "set_vertex".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_vertex" } - } - val setVertexBones: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "set_vertex_bones".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_vertex_bones" } - } - val setVertexColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "set_vertex_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_vertex_color" } - } - val setVertexMeta: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "set_vertex_meta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_vertex_meta" } - } - val setVertexNormal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "set_vertex_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_vertex_normal" } - } - val setVertexTangent: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "set_vertex_tangent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_vertex_tangent" } - } - val setVertexUv: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "set_vertex_uv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_vertex_uv" } - } - val setVertexUv2: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "set_vertex_uv2".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_vertex_uv2" } - } - val setVertexWeights: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, - "set_vertex_weights".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_vertex_weights" } - }} + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val commitToSurface: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "commit_to_surface".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method commit_to_surface" } + } + } + + val createFromSurface: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "create_from_surface".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_from_surface" } + } + } + + val getEdgeCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_edge_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_edge_count" } + } + } + + val getEdgeFaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_edge_faces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_edge_faces" } + } + } + + val getEdgeMeta: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_edge_meta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_edge_meta" } + } + } + + val getEdgeVertex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_edge_vertex".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_edge_vertex" } + } + } + + val getFaceCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_face_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_face_count" } + } + } + + val getFaceEdge: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_face_edge".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_face_edge" } + } + } + + val getFaceMeta: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_face_meta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_face_meta" } + } + } + + val getFaceNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_face_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_face_normal" } + } + } + + val getFaceVertex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_face_vertex".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_face_vertex" } + } + } + + val getFormat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_format".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_format" } + } + } + + val getMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_material" } + } + } + + val getVertex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_vertex".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vertex" } + } + } + + val getVertexBones: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_vertex_bones".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vertex_bones" } + } + } + + val getVertexColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_vertex_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vertex_color" } + } + } + + val getVertexCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_vertex_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vertex_count" } + } + } + + val getVertexEdges: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_vertex_edges".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vertex_edges" } + } + } + + val getVertexFaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_vertex_faces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vertex_faces" } + } + } + + val getVertexMeta: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_vertex_meta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vertex_meta" } + } + } + + val getVertexNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_vertex_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vertex_normal" } + } + } + + val getVertexTangent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_vertex_tangent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vertex_tangent" } + } + } + + val getVertexUv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_vertex_uv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vertex_uv" } + } + } + + val getVertexUv2: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_vertex_uv2".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vertex_uv2" } + } + } + + val getVertexWeights: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "get_vertex_weights".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vertex_weights" } + } + } + + val setEdgeMeta: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "set_edge_meta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_edge_meta" } + } + } + + val setFaceMeta: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "set_face_meta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_face_meta" } + } + } + + val setMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "set_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_material" } + } + } + + val setVertex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "set_vertex".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_vertex" } + } + } + + val setVertexBones: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "set_vertex_bones".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_vertex_bones" } + } + } + + val setVertexColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "set_vertex_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_vertex_color" } + } + } + + val setVertexMeta: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "set_vertex_meta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_vertex_meta" } + } + } + + val setVertexNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "set_vertex_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_vertex_normal" } + } + } + + val setVertexTangent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "set_vertex_tangent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_vertex_tangent" } + } + } + + val setVertexUv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "set_vertex_uv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_vertex_uv" } + } + } + + val setVertexUv2: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "set_vertex_uv2".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_vertex_uv2" } + } + } + + val setVertexWeights: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshDataTool".cstr.ptr, + "set_vertex_weights".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_vertex_weights" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/MeshInstance.kt b/godot-kotlin/src/nativeGen/kotlin/godot/MeshInstance.kt index 5be7a7cb..1a14f029 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/MeshInstance.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/MeshInstance.kt @@ -196,89 +196,113 @@ open class MeshInstance( * Container for method_bind pointers for MeshInstance */ private object __method_bind { - val createConvexCollision: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, - "create_convex_collision".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_convex_collision" } - } - val createDebugTangents: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, - "create_debug_tangents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_debug_tangents" } - } - val createTrimeshCollision: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, - "create_trimesh_collision".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_trimesh_collision" } - } - val getMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, - "get_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mesh" } - } - val getSkeletonPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, - "get_skeleton_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_skeleton_path" } - } - val getSkin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, - "get_skin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_skin" } - } - val getSurfaceMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, - "get_surface_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_surface_material" } - } - val getSurfaceMaterialCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, - "get_surface_material_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_surface_material_count" } - } - val setMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, - "set_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mesh" } - } - val setSkeletonPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, - "set_skeleton_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_skeleton_path" } - } - val setSkin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, - "set_skin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_skin" } - } - val setSurfaceMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, - "set_surface_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_surface_material" } - }} + val createConvexCollision: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, + "create_convex_collision".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_convex_collision" } + } + } + + val createDebugTangents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, + "create_debug_tangents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_debug_tangents" } + } + } + + val createTrimeshCollision: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, + "create_trimesh_collision".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_trimesh_collision" } + } + } + + val getMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, + "get_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mesh" } + } + } + + val getSkeletonPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, + "get_skeleton_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_skeleton_path" } + } + } + + val getSkin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, + "get_skin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_skin" } + } + } + + val getSurfaceMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, + "get_surface_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_surface_material" } + } + } + + val getSurfaceMaterialCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, + "get_surface_material_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_surface_material_count" } + } + } + + val setMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, + "set_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mesh" } + } + } + + val setSkeletonPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, + "set_skeleton_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_skeleton_path" } + } + } + + val setSkin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, + "set_skin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_skin" } + } + } + + val setSurfaceMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance".cstr.ptr, + "set_surface_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_surface_material" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/MeshInstance2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/MeshInstance2D.kt index fc14710d..98f6fdd3 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/MeshInstance2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/MeshInstance2D.kt @@ -134,47 +134,59 @@ open class MeshInstance2D( * Container for method_bind pointers for MeshInstance2D */ private object __method_bind { - val getMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance2D".cstr.ptr, - "get_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mesh" } - } - val getNormalMap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance2D".cstr.ptr, - "get_normal_map".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_normal_map" } - } - val getTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance2D".cstr.ptr, - "get_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture" } - } - val setMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance2D".cstr.ptr, - "set_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mesh" } - } - val setNormalMap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance2D".cstr.ptr, - "set_normal_map".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_normal_map" } - } - val setTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance2D".cstr.ptr, - "set_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture" } - }} + val getMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance2D".cstr.ptr, + "get_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mesh" } + } + } + + val getNormalMap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance2D".cstr.ptr, + "get_normal_map".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_normal_map" } + } + } + + val getTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance2D".cstr.ptr, + "get_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture" } + } + } + + val setMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance2D".cstr.ptr, + "set_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mesh" } + } + } + + val setNormalMap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance2D".cstr.ptr, + "set_normal_map".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_normal_map" } + } + } + + val setTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshInstance2D".cstr.ptr, + "set_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/MeshLibrary.kt b/godot-kotlin/src/nativeGen/kotlin/godot/MeshLibrary.kt index abb665a2..d44cb0b5 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/MeshLibrary.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/MeshLibrary.kt @@ -231,131 +231,167 @@ open class MeshLibrary( * Container for method_bind pointers for MeshLibrary */ private object __method_bind { - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val createItem: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, - "create_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_item" } - } - val findItemByName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, - "find_item_by_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method find_item_by_name" } - } - val getItemList: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, - "get_item_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_list" } - } - val getItemMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, - "get_item_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_mesh" } - } - val getItemName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, - "get_item_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_name" } - } - val getItemNavmesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, - "get_item_navmesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_navmesh" } - } - val getItemNavmeshTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, - "get_item_navmesh_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_navmesh_transform" } - } - val getItemPreview: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, - "get_item_preview".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_preview" } - } - val getItemShapes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, - "get_item_shapes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_shapes" } - } - val getLastUnusedItemId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, - "get_last_unused_item_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_last_unused_item_id" } - } - val removeItem: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, - "remove_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_item" } - } - val setItemMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, - "set_item_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_mesh" } - } - val setItemName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, - "set_item_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_name" } - } - val setItemNavmesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, - "set_item_navmesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_navmesh" } - } - val setItemNavmeshTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, - "set_item_navmesh_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_navmesh_transform" } - } - val setItemPreview: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, - "set_item_preview".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_preview" } - } - val setItemShapes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, - "set_item_shapes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_shapes" } - }} + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val createItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, + "create_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_item" } + } + } + + val findItemByName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, + "find_item_by_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method find_item_by_name" } + } + } + + val getItemList: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, + "get_item_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_list" } + } + } + + val getItemMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, + "get_item_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_mesh" } + } + } + + val getItemName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, + "get_item_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_name" } + } + } + + val getItemNavmesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, + "get_item_navmesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_navmesh" } + } + } + + val getItemNavmeshTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, + "get_item_navmesh_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_navmesh_transform" } + } + } + + val getItemPreview: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, + "get_item_preview".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_preview" } + } + } + + val getItemShapes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, + "get_item_shapes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_shapes" } + } + } + + val getLastUnusedItemId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, + "get_last_unused_item_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_last_unused_item_id" } + } + } + + val removeItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, + "remove_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_item" } + } + } + + val setItemMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, + "set_item_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_mesh" } + } + } + + val setItemName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, + "set_item_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_name" } + } + } + + val setItemNavmesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, + "set_item_navmesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_navmesh" } + } + } + + val setItemNavmeshTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, + "set_item_navmesh_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_navmesh_transform" } + } + } + + val setItemPreview: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, + "set_item_preview".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_preview" } + } + } + + val setItemShapes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshLibrary".cstr.ptr, + "set_item_shapes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_shapes" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/MeshTexture.kt b/godot-kotlin/src/nativeGen/kotlin/godot/MeshTexture.kt index f44f89e3..60b5f10c 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/MeshTexture.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/MeshTexture.kt @@ -138,47 +138,59 @@ open class MeshTexture( * Container for method_bind pointers for MeshTexture */ private object __method_bind { - val getBaseTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshTexture".cstr.ptr, - "get_base_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base_texture" } - } - val getImageSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshTexture".cstr.ptr, - "get_image_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_image_size" } - } - val getMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshTexture".cstr.ptr, - "get_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mesh" } - } - val setBaseTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshTexture".cstr.ptr, - "set_base_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_base_texture" } - } - val setImageSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshTexture".cstr.ptr, - "set_image_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_image_size" } - } - val setMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshTexture".cstr.ptr, - "set_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mesh" } - }} + val getBaseTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshTexture".cstr.ptr, + "get_base_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base_texture" } + } + } + + val getImageSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshTexture".cstr.ptr, + "get_image_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_image_size" } + } + } + + val getMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshTexture".cstr.ptr, + "get_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mesh" } + } + } + + val setBaseTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshTexture".cstr.ptr, + "set_base_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_base_texture" } + } + } + + val setImageSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshTexture".cstr.ptr, + "set_image_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_image_size" } + } + } + + val setMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MeshTexture".cstr.ptr, + "set_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mesh" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/MobileVRInterface.kt b/godot-kotlin/src/nativeGen/kotlin/godot/MobileVRInterface.kt index 33f686ce..1e805278 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/MobileVRInterface.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/MobileVRInterface.kt @@ -224,103 +224,131 @@ open class MobileVRInterface( * Container for method_bind pointers for MobileVRInterface */ private object __method_bind { - val getDisplayToLens: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, - "get_display_to_lens".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_display_to_lens" } - } - val getDisplayWidth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, - "get_display_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_display_width" } - } - val getEyeHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, - "get_eye_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_eye_height" } - } - val getIod: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, - "get_iod".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_iod" } - } - val getK1: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, - "get_k1".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_k1" } - } - val getK2: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, - "get_k2".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_k2" } - } - val getOversample: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, - "get_oversample".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_oversample" } - } - val setDisplayToLens: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, - "set_display_to_lens".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_display_to_lens" } - } - val setDisplayWidth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, - "set_display_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_display_width" } - } - val setEyeHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, - "set_eye_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_eye_height" } - } - val setIod: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, - "set_iod".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_iod" } - } - val setK1: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, - "set_k1".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_k1" } - } - val setK2: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, - "set_k2".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_k2" } - } - val setOversample: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, - "set_oversample".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_oversample" } - }} + val getDisplayToLens: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, + "get_display_to_lens".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_display_to_lens" } + } + } + + val getDisplayWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, + "get_display_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_display_width" } + } + } + + val getEyeHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, + "get_eye_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_eye_height" } + } + } + + val getIod: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, + "get_iod".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_iod" } + } + } + + val getK1: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, + "get_k1".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_k1" } + } + } + + val getK2: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, + "get_k2".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_k2" } + } + } + + val getOversample: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, + "get_oversample".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_oversample" } + } + } + + val setDisplayToLens: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, + "set_display_to_lens".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_display_to_lens" } + } + } + + val setDisplayWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, + "set_display_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_display_width" } + } + } + + val setEyeHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, + "set_eye_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_eye_height" } + } + } + + val setIod: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, + "set_iod".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_iod" } + } + } + + val setK1: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, + "set_k1".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_k1" } + } + } + + val setK2: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, + "set_k2".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_k2" } + } + } + + val setOversample: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MobileVRInterface".cstr.ptr, + "set_oversample".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_oversample" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/MultiMesh.kt b/godot-kotlin/src/nativeGen/kotlin/godot/MultiMesh.kt index 7fd576b7..0b74b5a0 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/MultiMesh.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/MultiMesh.kt @@ -403,137 +403,203 @@ open class MultiMesh( * Container for method_bind pointers for MultiMesh */ private object __method_bind { - val getAabb: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "get_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_aabb" } - } - val getColorFormat: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "get_color_format".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_color_format" } - } - val getCustomDataFormat: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "get_custom_data_format".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_custom_data_format" } - } - val getInstanceColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "get_instance_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_instance_color" } - } - val getInstanceCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "get_instance_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_instance_count" } - } - val getInstanceCustomData: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "get_instance_custom_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_instance_custom_data" } - } - val getInstanceTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "get_instance_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_instance_transform" } - } - val getInstanceTransform2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "get_instance_transform_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_instance_transform_2d" } - } - val getMesh: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "get_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mesh" } - } - val getTransformFormat: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "get_transform_format".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_transform_format" } - } - val getVisibleInstanceCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "get_visible_instance_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_visible_instance_count" } - } - val setAsBulkArray: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "set_as_bulk_array".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_as_bulk_array" } - } - val setColorFormat: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "set_color_format".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_color_format" } - } - val setCustomDataFormat: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "set_custom_data_format".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_custom_data_format" } - } - val setInstanceColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "set_instance_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_instance_color" } - } - val setInstanceCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "set_instance_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_instance_count" } - } - val setInstanceCustomData: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "set_instance_custom_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_instance_custom_data" } - } - val setInstanceTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "set_instance_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_instance_transform" } - } - val setInstanceTransform2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "set_instance_transform_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_instance_transform_2d" } - } - val setMesh: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "set_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mesh" } - } - val setTransformFormat: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "set_transform_format".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_transform_format" } - } - val setVisibleInstanceCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, - "set_visible_instance_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_visible_instance_count" } - }} + val getAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "get_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_aabb" } + } + } + + val getColorFormat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "get_color_format".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_color_format" } + } + } + + val getCustomDataFormat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "get_custom_data_format".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_custom_data_format" } + } + } + + val getInstanceColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "get_instance_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_instance_color" } + } + } + + val getInstanceCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "get_instance_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_instance_count" } + } + } + + val getInstanceCustomData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "get_instance_custom_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_instance_custom_data" } + } + } + + val getInstanceTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "get_instance_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_instance_transform" } + } + } + + val getInstanceTransform2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "get_instance_transform_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_instance_transform_2d" } + } + } + + val getMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "get_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mesh" } + } + } + + val getTransformFormat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "get_transform_format".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_transform_format" } + } + } + + val getVisibleInstanceCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "get_visible_instance_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_visible_instance_count" } + } + } + + val setAsBulkArray: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "set_as_bulk_array".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_as_bulk_array" } + } + } + + val setColorFormat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "set_color_format".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_color_format" } + } + } + + val setCustomDataFormat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "set_custom_data_format".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_custom_data_format" } + } + } + + val setInstanceColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "set_instance_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_instance_color" } + } + } + + val setInstanceCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "set_instance_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_instance_count" } + } + } + + val setInstanceCustomData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "set_instance_custom_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_instance_custom_data" } + } + } + + val setInstanceTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "set_instance_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_instance_transform" } + } + } + + val setInstanceTransform2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "set_instance_transform_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_instance_transform_2d" } + } + } + + val setMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "set_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mesh" } + } + } + + val setTransformFormat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "set_transform_format".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_transform_format" } + } + } + + val setVisibleInstanceCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMesh".cstr.ptr, + "set_visible_instance_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_visible_instance_count" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/MultiMeshInstance.kt b/godot-kotlin/src/nativeGen/kotlin/godot/MultiMeshInstance.kt index 32c65f00..41e08b9a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/MultiMeshInstance.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/MultiMeshInstance.kt @@ -75,19 +75,23 @@ open class MultiMeshInstance( * Container for method_bind pointers for MultiMeshInstance */ private object __method_bind { - val getMultimesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMeshInstance".cstr.ptr, - "get_multimesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_multimesh" } - } - val setMultimesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMeshInstance".cstr.ptr, - "set_multimesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_multimesh" } - }} + val getMultimesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMeshInstance".cstr.ptr, + "get_multimesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_multimesh" } + } + } + + val setMultimesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMeshInstance".cstr.ptr, + "set_multimesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_multimesh" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/MultiMeshInstance2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/MultiMeshInstance2D.kt index 3a75fcf7..d3d1aa2c 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/MultiMeshInstance2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/MultiMeshInstance2D.kt @@ -134,47 +134,59 @@ open class MultiMeshInstance2D( * Container for method_bind pointers for MultiMeshInstance2D */ private object __method_bind { - val getMultimesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMeshInstance2D".cstr.ptr, - "get_multimesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_multimesh" } - } - val getNormalMap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMeshInstance2D".cstr.ptr, - "get_normal_map".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_normal_map" } - } - val getTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMeshInstance2D".cstr.ptr, - "get_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture" } - } - val setMultimesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMeshInstance2D".cstr.ptr, - "set_multimesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_multimesh" } - } - val setNormalMap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMeshInstance2D".cstr.ptr, - "set_normal_map".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_normal_map" } - } - val setTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMeshInstance2D".cstr.ptr, - "set_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture" } - }} + val getMultimesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMeshInstance2D".cstr.ptr, + "get_multimesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_multimesh" } + } + } + + val getNormalMap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMeshInstance2D".cstr.ptr, + "get_normal_map".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_normal_map" } + } + } + + val getTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMeshInstance2D".cstr.ptr, + "get_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture" } + } + } + + val setMultimesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMeshInstance2D".cstr.ptr, + "set_multimesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_multimesh" } + } + } + + val setNormalMap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMeshInstance2D".cstr.ptr, + "set_normal_map".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_normal_map" } + } + } + + val setTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiMeshInstance2D".cstr.ptr, + "set_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/MultiplayerAPI.kt b/godot-kotlin/src/nativeGen/kotlin/godot/MultiplayerAPI.kt index 0b2cb55d..34e6a06b 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/MultiplayerAPI.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/MultiplayerAPI.kt @@ -303,112 +303,142 @@ open class MultiplayerAPI( * Container for method_bind pointers for MultiplayerAPI */ private object __method_bind { - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val getNetworkConnectedPeers: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, - "get_network_connected_peers".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_network_connected_peers" } - } - val getNetworkPeer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, - "get_network_peer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_network_peer" } - } - val getNetworkUniqueId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, - "get_network_unique_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_network_unique_id" } - } - val getRpcSenderId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, - "get_rpc_sender_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rpc_sender_id" } - } - val hasNetworkPeer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, - "has_network_peer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_network_peer" } - } - val isNetworkServer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, - "is_network_server".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_network_server" } - } - val isObjectDecodingAllowed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, - "is_object_decoding_allowed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_object_decoding_allowed" } - } - val isRefusingNewNetworkConnections: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, - "is_refusing_new_network_connections".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method is_refusing_new_network_connections" } - } - val poll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, - "poll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method poll" } - } - val sendBytes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, - "send_bytes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method send_bytes" } - } - val setAllowObjectDecoding: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, - "set_allow_object_decoding".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_allow_object_decoding" } - } - val setNetworkPeer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, - "set_network_peer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_network_peer" } - } - val setRefuseNewNetworkConnections: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, - "set_refuse_new_network_connections".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_refuse_new_network_connections" + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } } - } - val setRootNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, - "set_root_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_root_node" } - }} + } + + val getNetworkConnectedPeers: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, + "get_network_connected_peers".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_network_connected_peers" } + } + } + + val getNetworkPeer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, + "get_network_peer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_network_peer" } + } + } + + val getNetworkUniqueId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, + "get_network_unique_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_network_unique_id" } + } + } + + val getRpcSenderId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, + "get_rpc_sender_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rpc_sender_id" } + } + } + + val hasNetworkPeer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, + "has_network_peer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_network_peer" } + } + } + + val isNetworkServer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, + "is_network_server".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_network_server" } + } + } + + val isObjectDecodingAllowed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, + "is_object_decoding_allowed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_object_decoding_allowed" } + } + } + + val isRefusingNewNetworkConnections: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, + "is_refusing_new_network_connections".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_refusing_new_network_connections" } + } + } + + val poll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, + "poll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method poll" } + } + } + + val sendBytes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, + "send_bytes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method send_bytes" } + } + } + + val setAllowObjectDecoding: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, + "set_allow_object_decoding".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_allow_object_decoding" } + } + } + + val setNetworkPeer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, + "set_network_peer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_network_peer" } + } + } + + val setRefuseNewNetworkConnections: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, + "set_refuse_new_network_connections".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_refuse_new_network_connections" } + } + } + + val setRootNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("MultiplayerAPI".cstr.ptr, + "set_root_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_root_node" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Mutex.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Mutex.kt index b9fec823..1b105470 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Mutex.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Mutex.kt @@ -72,23 +72,29 @@ open class Mutex( * Container for method_bind pointers for Mutex */ private object __method_bind { - val lock: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Mutex".cstr.ptr, - "lock".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method lock" } - } - val tryLock: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Mutex".cstr.ptr, - "try_lock".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method try_lock" } - } - val unlock: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Mutex".cstr.ptr, - "unlock".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method unlock" } - }} + val lock: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Mutex".cstr.ptr, + "lock".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method lock" } + } + } + + val tryLock: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Mutex".cstr.ptr, + "try_lock".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method try_lock" } + } + } + + val unlock: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Mutex".cstr.ptr, + "unlock".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method unlock" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/NativeScript.kt b/godot-kotlin/src/nativeGen/kotlin/godot/NativeScript.kt index ca967ace..bd00acdc 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/NativeScript.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/NativeScript.kt @@ -204,96 +204,122 @@ open class NativeScript( * Container for method_bind pointers for NativeScript */ private object __method_bind { - val getClassDocumentation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, - "get_class_documentation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_class_documentation" } - } - val getClassName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, - "get_class_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_class_name" } - } - val getLibrary: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, - "get_library".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_library" } - } - val getMethodDocumentation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, - "get_method_documentation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_method_documentation" } - } - val getPropertyDocumentation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, - "get_property_documentation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_property_documentation" } - } - val getScriptClassIconPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, - "get_script_class_icon_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_script_class_icon_path" } - } - val getScriptClassName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, - "get_script_class_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_script_class_name" } - } - val getSignalDocumentation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, - "get_signal_documentation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_signal_documentation" } - } - val new: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, - "new".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method new" } - } - val setClassName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, - "set_class_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_class_name" } - } - val setLibrary: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, - "set_library".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_library" } - } - val setScriptClassIconPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, - "set_script_class_icon_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_script_class_icon_path" } - } - val setScriptClassName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, - "set_script_class_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_script_class_name" } - }} + val getClassDocumentation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, + "get_class_documentation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_class_documentation" } + } + } + + val getClassName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, + "get_class_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_class_name" } + } + } + + val getLibrary: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, + "get_library".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_library" } + } + } + + val getMethodDocumentation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, + "get_method_documentation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_method_documentation" } + } + } + + val getPropertyDocumentation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, + "get_property_documentation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_property_documentation" } + } + } + + val getScriptClassIconPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, + "get_script_class_icon_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_script_class_icon_path" } + } + } + + val getScriptClassName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, + "get_script_class_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_script_class_name" } + } + } + + val getSignalDocumentation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, + "get_signal_documentation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_signal_documentation" } + } + } + + val new: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, + "new".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method new" } + } + } + + val setClassName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, + "set_class_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_class_name" } + } + } + + val setLibrary: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, + "set_library".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_library" } + } + } + + val setScriptClassIconPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, + "set_script_class_icon_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_script_class_icon_path" } + } + } + + val setScriptClassName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NativeScript".cstr.ptr, + "set_script_class_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_script_class_name" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Navigation.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Navigation.kt index b22f6a09..04dbceed 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Navigation.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Navigation.kt @@ -195,65 +195,95 @@ open class Navigation( * Container for method_bind pointers for Navigation */ private object __method_bind { - val getClosestPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, - "get_closest_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_closest_point" } - } - val getClosestPointNormal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, - "get_closest_point_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_closest_point_normal" } - } - val getClosestPointOwner: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, - "get_closest_point_owner".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_closest_point_owner" } - } - val getClosestPointToSegment: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, - "get_closest_point_to_segment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_closest_point_to_segment" } - } - val getSimplePath: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, - "get_simple_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_simple_path" } - } - val getUpVector: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, - "get_up_vector".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_up_vector" } - } - val navmeshAdd: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, - "navmesh_add".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method navmesh_add" } - } - val navmeshRemove: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, - "navmesh_remove".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method navmesh_remove" } - } - val navmeshSetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, - "navmesh_set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method navmesh_set_transform" } - } - val setUpVector: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, - "set_up_vector".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_up_vector" } - }} + val getClosestPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, + "get_closest_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_closest_point" } + } + } + + val getClosestPointNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, + "get_closest_point_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_closest_point_normal" } + } + } + + val getClosestPointOwner: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, + "get_closest_point_owner".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_closest_point_owner" } + } + } + + val getClosestPointToSegment: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, + "get_closest_point_to_segment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_closest_point_to_segment" } + } + } + + val getSimplePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, + "get_simple_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_simple_path" } + } + } + + val getUpVector: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, + "get_up_vector".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_up_vector" } + } + } + + val navmeshAdd: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, + "navmesh_add".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method navmesh_add" } + } + } + + val navmeshRemove: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, + "navmesh_remove".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method navmesh_remove" } + } + } + + val navmeshSetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, + "navmesh_set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method navmesh_set_transform" } + } + } + + val setUpVector: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation".cstr.ptr, + "set_up_vector".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_up_vector" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Navigation2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Navigation2D.kt index 20a8748e..ad9b0c73 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Navigation2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Navigation2D.kt @@ -129,47 +129,59 @@ open class Navigation2D( * Container for method_bind pointers for Navigation2D */ private object __method_bind { - val getClosestPoint: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation2D".cstr.ptr, - "get_closest_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_closest_point" } - } - val getClosestPointOwner: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation2D".cstr.ptr, - "get_closest_point_owner".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_closest_point_owner" } - } - val getSimplePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation2D".cstr.ptr, - "get_simple_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_simple_path" } - } - val navpolyAdd: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation2D".cstr.ptr, - "navpoly_add".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method navpoly_add" } - } - val navpolyRemove: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation2D".cstr.ptr, - "navpoly_remove".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method navpoly_remove" } - } - val navpolySetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation2D".cstr.ptr, - "navpoly_set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method navpoly_set_transform" } - }} + val getClosestPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation2D".cstr.ptr, + "get_closest_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_closest_point" } + } + } + + val getClosestPointOwner: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation2D".cstr.ptr, + "get_closest_point_owner".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_closest_point_owner" } + } + } + + val getSimplePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation2D".cstr.ptr, + "get_simple_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_simple_path" } + } + } + + val navpolyAdd: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation2D".cstr.ptr, + "navpoly_add".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method navpoly_add" } + } + } + + val navpolyRemove: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation2D".cstr.ptr, + "navpoly_remove".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method navpoly_remove" } + } + } + + val navpolySetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Navigation2D".cstr.ptr, + "navpoly_set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method navpoly_set_transform" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/NavigationMesh.kt b/godot-kotlin/src/nativeGen/kotlin/godot/NavigationMesh.kt index 89b25d41..bc05fb33 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/NavigationMesh.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/NavigationMesh.kt @@ -699,364 +699,468 @@ open class NavigationMesh( * Container for method_bind pointers for NavigationMesh */ private object __method_bind { - val addPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "add_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_polygon" } - } - val clearPolygons: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "clear_polygons".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_polygons" } - } - val createFromMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "create_from_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_from_mesh" } - } - val getAgentHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_agent_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_agent_height" } - } - val getAgentMaxClimb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_agent_max_climb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_agent_max_climb" } - } - val getAgentMaxSlope: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_agent_max_slope".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_agent_max_slope" } - } - val getAgentRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_agent_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_agent_radius" } - } - val getCellHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_cell_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cell_height" } - } - val getCellSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_cell_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cell_size" } - } - val getCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } - } - val getCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } - } - val getDetailSampleDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_detail_sample_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_detail_sample_distance" } - } - val getDetailSampleMaxError: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_detail_sample_max_error".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_detail_sample_max_error" } - } - val getEdgeMaxError: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_edge_max_error".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_edge_max_error" } - } - val getEdgeMaxLength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_edge_max_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_edge_max_length" } - } - val getFilterLedgeSpans: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_filter_ledge_spans".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_filter_ledge_spans" } - } - val getFilterLowHangingObstacles: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_filter_low_hanging_obstacles".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_filter_low_hanging_obstacles" } - } - val getFilterWalkableLowHeightSpans: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_filter_walkable_low_height_spans".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method get_filter_walkable_low_height_spans" } - } - val getParsedGeometryType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_parsed_geometry_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_parsed_geometry_type" } - } - val getPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_polygon" } - } - val getPolygonCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_polygon_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_polygon_count" } - } - val getRegionMergeSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_region_merge_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_region_merge_size" } - } - val getRegionMinSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_region_min_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_region_min_size" } - } - val getSamplePartitionType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_sample_partition_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sample_partition_type" } - } - val getSourceGeometryMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_source_geometry_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_source_geometry_mode" } - } - val getSourceGroupName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_source_group_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_source_group_name" } - } - val getVertices: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_vertices".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vertices" } - } - val getVertsPerPoly: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "get_verts_per_poly".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_verts_per_poly" } - } - val setAgentHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_agent_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_agent_height" } - } - val setAgentMaxClimb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_agent_max_climb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_agent_max_climb" } - } - val setAgentMaxSlope: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_agent_max_slope".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_agent_max_slope" } - } - val setAgentRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_agent_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_agent_radius" } - } - val setCellHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_cell_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cell_height" } - } - val setCellSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_cell_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cell_size" } - } - val setCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } - } - val setCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } - } - val setDetailSampleDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_detail_sample_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_detail_sample_distance" } - } - val setDetailSampleMaxError: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_detail_sample_max_error".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_detail_sample_max_error" } - } - val setEdgeMaxError: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_edge_max_error".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_edge_max_error" } - } - val setEdgeMaxLength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_edge_max_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_edge_max_length" } - } - val setFilterLedgeSpans: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_filter_ledge_spans".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_filter_ledge_spans" } - } - val setFilterLowHangingObstacles: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_filter_low_hanging_obstacles".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_filter_low_hanging_obstacles" } - } - val setFilterWalkableLowHeightSpans: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_filter_walkable_low_height_spans".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method set_filter_walkable_low_height_spans" } - } - val setParsedGeometryType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_parsed_geometry_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_parsed_geometry_type" } - } - val setRegionMergeSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_region_merge_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_region_merge_size" } - } - val setRegionMinSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_region_min_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_region_min_size" } - } - val setSamplePartitionType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_sample_partition_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sample_partition_type" } - } - val setSourceGeometryMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_source_geometry_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_source_geometry_mode" } - } - val setSourceGroupName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_source_group_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_source_group_name" } - } - val setVertices: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_vertices".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_vertices" } - } - val setVertsPerPoly: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, - "set_verts_per_poly".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_verts_per_poly" } - }} + val addPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "add_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_polygon" } + } + } + + val clearPolygons: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "clear_polygons".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_polygons" } + } + } + + val createFromMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "create_from_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_from_mesh" } + } + } + + val getAgentHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_agent_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_agent_height" } + } + } + + val getAgentMaxClimb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_agent_max_climb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_agent_max_climb" } + } + } + + val getAgentMaxSlope: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_agent_max_slope".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_agent_max_slope" } + } + } + + val getAgentRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_agent_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_agent_radius" } + } + } + + val getCellHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_cell_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cell_height" } + } + } + + val getCellSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_cell_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cell_size" } + } + } + + val getCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } + } + } + + val getCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } + } + } + + val getDetailSampleDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_detail_sample_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_detail_sample_distance" } + } + } + + val getDetailSampleMaxError: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_detail_sample_max_error".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_detail_sample_max_error" } + } + } + + val getEdgeMaxError: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_edge_max_error".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_edge_max_error" } + } + } + + val getEdgeMaxLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_edge_max_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_edge_max_length" } + } + } + + val getFilterLedgeSpans: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_filter_ledge_spans".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_filter_ledge_spans" } + } + } + + val getFilterLowHangingObstacles: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_filter_low_hanging_obstacles".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_filter_low_hanging_obstacles" } + } + } + + val getFilterWalkableLowHeightSpans: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_filter_walkable_low_height_spans".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_filter_walkable_low_height_spans" } + } + } + + val getParsedGeometryType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_parsed_geometry_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_parsed_geometry_type" } + } + } + + val getPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_polygon" } + } + } + + val getPolygonCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_polygon_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_polygon_count" } + } + } + + val getRegionMergeSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_region_merge_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_region_merge_size" } + } + } + + val getRegionMinSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_region_min_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_region_min_size" } + } + } + + val getSamplePartitionType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_sample_partition_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sample_partition_type" } + } + } + + val getSourceGeometryMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_source_geometry_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_source_geometry_mode" } + } + } + + val getSourceGroupName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_source_group_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_source_group_name" } + } + } + + val getVertices: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_vertices".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vertices" } + } + } + + val getVertsPerPoly: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "get_verts_per_poly".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_verts_per_poly" } + } + } + + val setAgentHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_agent_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_agent_height" } + } + } + + val setAgentMaxClimb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_agent_max_climb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_agent_max_climb" } + } + } + + val setAgentMaxSlope: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_agent_max_slope".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_agent_max_slope" } + } + } + + val setAgentRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_agent_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_agent_radius" } + } + } + + val setCellHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_cell_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cell_height" } + } + } + + val setCellSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_cell_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cell_size" } + } + } + + val setCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } + } + } + + val setCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } + } + } + + val setDetailSampleDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_detail_sample_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_detail_sample_distance" } + } + } + + val setDetailSampleMaxError: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_detail_sample_max_error".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_detail_sample_max_error" } + } + } + + val setEdgeMaxError: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_edge_max_error".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_edge_max_error" } + } + } + + val setEdgeMaxLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_edge_max_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_edge_max_length" } + } + } + + val setFilterLedgeSpans: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_filter_ledge_spans".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_filter_ledge_spans" } + } + } + + val setFilterLowHangingObstacles: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_filter_low_hanging_obstacles".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_filter_low_hanging_obstacles" } + } + } + + val setFilterWalkableLowHeightSpans: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_filter_walkable_low_height_spans".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_filter_walkable_low_height_spans" } + } + } + + val setParsedGeometryType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_parsed_geometry_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_parsed_geometry_type" } + } + } + + val setRegionMergeSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_region_merge_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_region_merge_size" } + } + } + + val setRegionMinSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_region_min_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_region_min_size" } + } + } + + val setSamplePartitionType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_sample_partition_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sample_partition_type" } + } + } + + val setSourceGeometryMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_source_geometry_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_source_geometry_mode" } + } + } + + val setSourceGroupName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_source_group_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_source_group_name" } + } + } + + val setVertices: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_vertices".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_vertices" } + } + } + + val setVertsPerPoly: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMesh".cstr.ptr, + "set_verts_per_poly".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_verts_per_poly" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/NavigationMeshInstance.kt b/godot-kotlin/src/nativeGen/kotlin/godot/NavigationMeshInstance.kt index 3333169f..b871e695 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/NavigationMeshInstance.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/NavigationMeshInstance.kt @@ -101,33 +101,41 @@ open class NavigationMeshInstance( * Container for method_bind pointers for NavigationMeshInstance */ private object __method_bind { - val getNavigationMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMeshInstance".cstr.ptr, - "get_navigation_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_navigation_mesh" } - } - val isEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMeshInstance".cstr.ptr, - "is_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_enabled" } - } - val setEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMeshInstance".cstr.ptr, - "set_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_enabled" } - } - val setNavigationMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMeshInstance".cstr.ptr, - "set_navigation_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_navigation_mesh" } - }} + val getNavigationMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMeshInstance".cstr.ptr, + "get_navigation_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_navigation_mesh" } + } + } + + val isEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMeshInstance".cstr.ptr, + "is_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_enabled" } + } + } + + val setEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMeshInstance".cstr.ptr, + "set_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_enabled" } + } + } + + val setNavigationMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationMeshInstance".cstr.ptr, + "set_navigation_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_navigation_mesh" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/NavigationPolygon.kt b/godot-kotlin/src/nativeGen/kotlin/godot/NavigationPolygon.kt index 63cdbda1..8c510c8d 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/NavigationPolygon.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/NavigationPolygon.kt @@ -207,103 +207,131 @@ open class NavigationPolygon( * Container for method_bind pointers for NavigationPolygon */ private object __method_bind { - val addOutline: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, - "add_outline".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_outline" } - } - val addOutlineAtIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, - "add_outline_at_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_outline_at_index" } - } - val addPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, - "add_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_polygon" } - } - val clearOutlines: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, - "clear_outlines".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_outlines" } - } - val clearPolygons: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, - "clear_polygons".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_polygons" } - } - val getOutline: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, - "get_outline".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_outline" } - } - val getOutlineCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, - "get_outline_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_outline_count" } - } - val getPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, - "get_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_polygon" } - } - val getPolygonCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, - "get_polygon_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_polygon_count" } - } - val getVertices: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, - "get_vertices".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vertices" } - } - val makePolygonsFromOutlines: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, - "make_polygons_from_outlines".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method make_polygons_from_outlines" } - } - val removeOutline: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, - "remove_outline".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_outline" } - } - val setOutline: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, - "set_outline".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_outline" } - } - val setVertices: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, - "set_vertices".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_vertices" } - }} + val addOutline: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, + "add_outline".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_outline" } + } + } + + val addOutlineAtIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, + "add_outline_at_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_outline_at_index" } + } + } + + val addPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, + "add_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_polygon" } + } + } + + val clearOutlines: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, + "clear_outlines".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_outlines" } + } + } + + val clearPolygons: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, + "clear_polygons".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_polygons" } + } + } + + val getOutline: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, + "get_outline".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_outline" } + } + } + + val getOutlineCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, + "get_outline_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_outline_count" } + } + } + + val getPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, + "get_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_polygon" } + } + } + + val getPolygonCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, + "get_polygon_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_polygon_count" } + } + } + + val getVertices: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, + "get_vertices".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vertices" } + } + } + + val makePolygonsFromOutlines: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, + "make_polygons_from_outlines".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method make_polygons_from_outlines" } + } + } + + val removeOutline: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, + "remove_outline".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_outline" } + } + } + + val setOutline: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, + "set_outline".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_outline" } + } + } + + val setVertices: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygon".cstr.ptr, + "set_vertices".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_vertices" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/NavigationPolygonInstance.kt b/godot-kotlin/src/nativeGen/kotlin/godot/NavigationPolygonInstance.kt index 1bef5efd..f25beb92 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/NavigationPolygonInstance.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/NavigationPolygonInstance.kt @@ -105,33 +105,41 @@ open class NavigationPolygonInstance( * Container for method_bind pointers for NavigationPolygonInstance */ private object __method_bind { - val getNavigationPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygonInstance".cstr.ptr, - "get_navigation_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_navigation_polygon" } - } - val isEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygonInstance".cstr.ptr, - "is_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_enabled" } - } - val setEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygonInstance".cstr.ptr, - "set_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_enabled" } - } - val setNavigationPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygonInstance".cstr.ptr, - "set_navigation_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_navigation_polygon" } - }} + val getNavigationPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygonInstance".cstr.ptr, + "get_navigation_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_navigation_polygon" } + } + } + + val isEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygonInstance".cstr.ptr, + "is_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_enabled" } + } + } + + val setEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygonInstance".cstr.ptr, + "set_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_enabled" } + } + } + + val setNavigationPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NavigationPolygonInstance".cstr.ptr, + "set_navigation_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_navigation_polygon" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/NetworkedMultiplayerENet.kt b/godot-kotlin/src/nativeGen/kotlin/godot/NetworkedMultiplayerENet.kt index 9a8e8a2b..4c780f66 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/NetworkedMultiplayerENet.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/NetworkedMultiplayerENet.kt @@ -308,138 +308,176 @@ open class NetworkedMultiplayerENet( * Container for method_bind pointers for NetworkedMultiplayerENet */ private object __method_bind { - val closeConnection: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, - "close_connection".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method close_connection" } - } - val createClient: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, - "create_client".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_client" } - } - val createServer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, - "create_server".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_server" } - } - val disconnectPeer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, - "disconnect_peer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method disconnect_peer" } - } - val getChannelCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, - "get_channel_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_channel_count" } - } - val getCompressionMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, - "get_compression_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_compression_mode" } - } - val getLastPacketChannel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, - "get_last_packet_channel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_last_packet_channel" } - } - val getPacketChannel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, - "get_packet_channel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_packet_channel" } - } - val getPeerAddress: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, - "get_peer_address".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_peer_address" } - } - val getPeerPort: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, - "get_peer_port".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_peer_port" } - } - val getTransferChannel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, - "get_transfer_channel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_transfer_channel" } - } - val isAlwaysOrdered: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, - "is_always_ordered".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_always_ordered" } - } - val isServerRelayEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, - "is_server_relay_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_server_relay_enabled" } - } - val setAlwaysOrdered: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, - "set_always_ordered".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_always_ordered" } - } - val setBindIp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, - "set_bind_ip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bind_ip" } - } - val setChannelCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, - "set_channel_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_channel_count" } - } - val setCompressionMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, - "set_compression_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_compression_mode" } - } - val setServerRelayEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, - "set_server_relay_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_server_relay_enabled" } - } - val setTransferChannel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, - "set_transfer_channel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_transfer_channel" } - }} + val closeConnection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, + "close_connection".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method close_connection" } + } + } + + val createClient: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, + "create_client".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_client" } + } + } + + val createServer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, + "create_server".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_server" } + } + } + + val disconnectPeer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, + "disconnect_peer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method disconnect_peer" } + } + } + + val getChannelCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, + "get_channel_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_channel_count" } + } + } + + val getCompressionMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, + "get_compression_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_compression_mode" } + } + } + + val getLastPacketChannel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, + "get_last_packet_channel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_last_packet_channel" } + } + } + + val getPacketChannel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, + "get_packet_channel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_packet_channel" } + } + } + + val getPeerAddress: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, + "get_peer_address".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_peer_address" } + } + } + + val getPeerPort: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, + "get_peer_port".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_peer_port" } + } + } + + val getTransferChannel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, + "get_transfer_channel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_transfer_channel" } + } + } + + val isAlwaysOrdered: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, + "is_always_ordered".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_always_ordered" } + } + } + + val isServerRelayEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, + "is_server_relay_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_server_relay_enabled" } + } + } + + val setAlwaysOrdered: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, + "set_always_ordered".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_always_ordered" } + } + } + + val setBindIp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, + "set_bind_ip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bind_ip" } + } + } + + val setChannelCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, + "set_channel_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_channel_count" } + } + } + + val setCompressionMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, + "set_compression_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_compression_mode" } + } + } + + val setServerRelayEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, + "set_server_relay_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_server_relay_enabled" } + } + } + + val setTransferChannel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerENet".cstr.ptr, + "set_transfer_channel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_transfer_channel" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/NetworkedMultiplayerPeer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/NetworkedMultiplayerPeer.kt index af6b9ed7..38f0af90 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/NetworkedMultiplayerPeer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/NetworkedMultiplayerPeer.kt @@ -208,68 +208,86 @@ open class NetworkedMultiplayerPeer( * Container for method_bind pointers for NetworkedMultiplayerPeer */ private object __method_bind { - val getConnectionStatus: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerPeer".cstr.ptr, - "get_connection_status".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connection_status" } - } - val getPacketPeer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerPeer".cstr.ptr, - "get_packet_peer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_packet_peer" } - } - val getTransferMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerPeer".cstr.ptr, - "get_transfer_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_transfer_mode" } - } - val getUniqueId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerPeer".cstr.ptr, - "get_unique_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_unique_id" } - } - val isRefusingNewConnections: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerPeer".cstr.ptr, - "is_refusing_new_connections".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_refusing_new_connections" } - } - val poll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerPeer".cstr.ptr, - "poll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method poll" } - } - val setRefuseNewConnections: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerPeer".cstr.ptr, - "set_refuse_new_connections".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_refuse_new_connections" } - } - val setTargetPeer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerPeer".cstr.ptr, - "set_target_peer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_target_peer" } - } - val setTransferMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerPeer".cstr.ptr, - "set_transfer_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_transfer_mode" } - }} + val getConnectionStatus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerPeer".cstr.ptr, + "get_connection_status".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connection_status" } + } + } + + val getPacketPeer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerPeer".cstr.ptr, + "get_packet_peer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_packet_peer" } + } + } + + val getTransferMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerPeer".cstr.ptr, + "get_transfer_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_transfer_mode" } + } + } + + val getUniqueId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerPeer".cstr.ptr, + "get_unique_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_unique_id" } + } + } + + val isRefusingNewConnections: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerPeer".cstr.ptr, + "is_refusing_new_connections".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_refusing_new_connections" } + } + } + + val poll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerPeer".cstr.ptr, + "poll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method poll" } + } + } + + val setRefuseNewConnections: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerPeer".cstr.ptr, + "set_refuse_new_connections".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_refuse_new_connections" } + } + } + + val setTargetPeer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerPeer".cstr.ptr, + "set_target_peer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_target_peer" } + } + } + + val setTransferMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NetworkedMultiplayerPeer".cstr.ptr, + "set_transfer_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_transfer_mode" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/NinePatchRect.kt b/godot-kotlin/src/nativeGen/kotlin/godot/NinePatchRect.kt index 0e1d98b9..6d5fd500 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/NinePatchRect.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/NinePatchRect.kt @@ -266,89 +266,113 @@ open class NinePatchRect( * Container for method_bind pointers for NinePatchRect */ private object __method_bind { - val getHAxisStretchMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, - "get_h_axis_stretch_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_h_axis_stretch_mode" } - } - val getPatchMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, - "get_patch_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_patch_margin" } - } - val getRegionRect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, - "get_region_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_region_rect" } - } - val getTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, - "get_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture" } - } - val getVAxisStretchMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, - "get_v_axis_stretch_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_v_axis_stretch_mode" } - } - val isDrawCenterEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, - "is_draw_center_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_draw_center_enabled" } - } - val setDrawCenter: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, - "set_draw_center".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_draw_center" } - } - val setHAxisStretchMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, - "set_h_axis_stretch_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_h_axis_stretch_mode" } - } - val setPatchMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, - "set_patch_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_patch_margin" } - } - val setRegionRect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, - "set_region_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_region_rect" } - } - val setTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, - "set_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture" } - } - val setVAxisStretchMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, - "set_v_axis_stretch_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_v_axis_stretch_mode" } - }} + val getHAxisStretchMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, + "get_h_axis_stretch_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_h_axis_stretch_mode" } + } + } + + val getPatchMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, + "get_patch_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_patch_margin" } + } + } + + val getRegionRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, + "get_region_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_region_rect" } + } + } + + val getTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, + "get_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture" } + } + } + + val getVAxisStretchMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, + "get_v_axis_stretch_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_v_axis_stretch_mode" } + } + } + + val isDrawCenterEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, + "is_draw_center_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_draw_center_enabled" } + } + } + + val setDrawCenter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, + "set_draw_center".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_draw_center" } + } + } + + val setHAxisStretchMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, + "set_h_axis_stretch_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_h_axis_stretch_mode" } + } + } + + val setPatchMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, + "set_patch_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_patch_margin" } + } + } + + val setRegionRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, + "set_region_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_region_rect" } + } + } + + val setTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, + "set_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture" } + } + } + + val setVAxisStretchMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NinePatchRect".cstr.ptr, + "set_v_axis_stretch_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_v_axis_stretch_mode" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Node.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Node.kt index 94704375..975efa0d 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Node.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Node.kt @@ -1140,530 +1140,708 @@ open class Node( * Container for method_bind pointers for Node */ private object __method_bind { - val addChild: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "add_child".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_child" } - } - val addChildBelowNode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "add_child_below_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_child_below_node" } - } - val addToGroup: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "add_to_group".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_to_group" } - } - val canProcess: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "can_process".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method can_process" } - } - val duplicate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "duplicate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method duplicate" } - } - val findNode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "find_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method find_node" } - } - val findParent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "find_parent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method find_parent" } - } - val getChild: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_child".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_child" } - } - val getChildCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_child_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_child_count" } - } - val getChildren: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_children".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_children" } - } - val getCustomMultiplayer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_custom_multiplayer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_custom_multiplayer" } - } - val getFilename: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_filename".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_filename" } - } - val getGroups: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_groups".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_groups" } - } - val getIndex: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_index" } - } - val getMultiplayer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_multiplayer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_multiplayer" } - } - val getName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_name" } - } - val getNetworkMaster: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_network_master".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_network_master" } - } - val getNode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node" } - } - val getNodeAndResource: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_node_and_resource".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_and_resource" } - } - val getNodeOrNull: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_node_or_null".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_or_null" } - } - val getOwner: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_owner".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_owner" } - } - val getParent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_parent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_parent" } - } - val getPath: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_path" } - } - val getPathTo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_path_to".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_path_to" } - } - val getPauseMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_pause_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pause_mode" } - } - val getPhysicsProcessDeltaTime: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_physics_process_delta_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_physics_process_delta_time" } - } - val getPositionInParent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_position_in_parent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_position_in_parent" } - } - val getProcessDeltaTime: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_process_delta_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_process_delta_time" } - } - val getProcessPriority: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_process_priority".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_process_priority" } - } - val getSceneInstanceLoadPlaceholder: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_scene_instance_load_placeholder".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method get_scene_instance_load_placeholder" } - } - val getTree: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_tree".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tree" } - } - val getViewport: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "get_viewport".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_viewport" } - } - val hasNode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "has_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_node" } - } - val hasNodeAndResource: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "has_node_and_resource".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_node_and_resource" } - } - val isAParentOf: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "is_a_parent_of".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_a_parent_of" } - } - val isDisplayedFolded: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "is_displayed_folded".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_displayed_folded" } - } - val isGreaterThan: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "is_greater_than".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_greater_than" } - } - val isInGroup: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "is_in_group".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_in_group" } - } - val isInsideTree: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "is_inside_tree".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_inside_tree" } - } - val isNetworkMaster: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "is_network_master".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_network_master" } - } - val isPhysicsProcessing: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "is_physics_processing".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_physics_processing" } - } - val isPhysicsProcessingInternal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "is_physics_processing_internal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_physics_processing_internal" } - } - val isProcessing: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "is_processing".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_processing" } - } - val isProcessingInput: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "is_processing_input".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_processing_input" } - } - val isProcessingInternal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "is_processing_internal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_processing_internal" } - } - val isProcessingUnhandledInput: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "is_processing_unhandled_input".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_processing_unhandled_input" } - } - val isProcessingUnhandledKeyInput: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "is_processing_unhandled_key_input".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_processing_unhandled_key_input" + val addChild: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "add_child".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_child" } } - } - val moveChild: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "move_child".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method move_child" } - } - val printStrayNodes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "print_stray_nodes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method print_stray_nodes" } - } - val printTree: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "print_tree".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method print_tree" } - } - val printTreePretty: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "print_tree_pretty".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method print_tree_pretty" } - } - val propagateCall: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "propagate_call".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method propagate_call" } - } - val propagateNotification: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "propagate_notification".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method propagate_notification" } - } - val queueFree: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "queue_free".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method queue_free" } - } - val raise: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "raise".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method raise" } - } - val removeAndSkip: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "remove_and_skip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_and_skip" } - } - val removeChild: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "remove_child".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_child" } - } - val removeFromGroup: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "remove_from_group".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_from_group" } - } - val replaceBy: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "replace_by".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method replace_by" } - } - val requestReady: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "request_ready".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method request_ready" } - } - val rpc: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "rpc".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rpc" } - } - val rpcConfig: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "rpc_config".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rpc_config" } - } - val rpcId: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "rpc_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rpc_id" } - } - val rpcUnreliable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "rpc_unreliable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rpc_unreliable" } - } - val rpcUnreliableId: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "rpc_unreliable_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rpc_unreliable_id" } - } - val rset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "rset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rset" } - } - val rsetConfig: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "rset_config".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rset_config" } - } - val rsetId: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "rset_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rset_id" } - } - val rsetUnreliable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "rset_unreliable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rset_unreliable" } - } - val rsetUnreliableId: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "rset_unreliable_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rset_unreliable_id" } - } - val setCustomMultiplayer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "set_custom_multiplayer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_custom_multiplayer" } - } - val setDisplayFolded: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "set_display_folded".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_display_folded" } - } - val setFilename: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "set_filename".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_filename" } - } - val setName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "set_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_name" } - } - val setNetworkMaster: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "set_network_master".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_network_master" } - } - val setOwner: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "set_owner".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_owner" } - } - val setPauseMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "set_pause_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pause_mode" } - } - val setPhysicsProcess: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "set_physics_process".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_physics_process" } - } - val setPhysicsProcessInternal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "set_physics_process_internal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_physics_process_internal" } - } - val setProcess: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "set_process".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_process" } - } - val setProcessInput: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "set_process_input".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_process_input" } - } - val setProcessInternal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "set_process_internal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_process_internal" } - } - val setProcessPriority: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "set_process_priority".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_process_priority" } - } - val setProcessUnhandledInput: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "set_process_unhandled_input".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_process_unhandled_input" } - } - val setProcessUnhandledKeyInput: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "set_process_unhandled_key_input".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_process_unhandled_key_input" } - } - val setSceneInstanceLoadPlaceholder: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "set_scene_instance_load_placeholder".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method set_scene_instance_load_placeholder" } - } - val updateConfigurationWarning: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, - "update_configuration_warning".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method update_configuration_warning" } - }} + } + + val addChildBelowNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "add_child_below_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_child_below_node" } + } + } + + val addToGroup: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "add_to_group".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_to_group" } + } + } + + val canProcess: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "can_process".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method can_process" } + } + } + + val duplicate: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "duplicate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method duplicate" } + } + } + + val findNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "find_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method find_node" } + } + } + + val findParent: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "find_parent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method find_parent" } + } + } + + val getChild: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_child".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_child" } + } + } + + val getChildCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_child_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_child_count" } + } + } + + val getChildren: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_children".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_children" } + } + } + + val getCustomMultiplayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_custom_multiplayer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_custom_multiplayer" } + } + } + + val getFilename: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_filename".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_filename" } + } + } + + val getGroups: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_groups".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_groups" } + } + } + + val getIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_index" } + } + } + + val getMultiplayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_multiplayer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_multiplayer" } + } + } + + val getName: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_name" } + } + } + + val getNetworkMaster: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_network_master".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_network_master" } + } + } + + val getNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node" } + } + } + + val getNodeAndResource: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_node_and_resource".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_and_resource" } + } + } + + val getNodeOrNull: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_node_or_null".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_or_null" } + } + } + + val getOwner: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_owner".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_owner" } + } + } + + val getParent: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_parent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_parent" } + } + } + + val getPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_path" } + } + } + + val getPathTo: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_path_to".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_path_to" } + } + } + + val getPauseMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_pause_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pause_mode" } + } + } + + val getPhysicsProcessDeltaTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_physics_process_delta_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_physics_process_delta_time" + } + } + } + + val getPositionInParent: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_position_in_parent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_position_in_parent" } + } + } + + val getProcessDeltaTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_process_delta_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_process_delta_time" } + } + } + + val getProcessPriority: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_process_priority".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_process_priority" } + } + } + + val getSceneInstanceLoadPlaceholder: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_scene_instance_load_placeholder".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_scene_instance_load_placeholder" } + } + } + + val getTree: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_tree".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tree" } + } + } + + val getViewport: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "get_viewport".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_viewport" } + } + } + + val hasNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "has_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_node" } + } + } + + val hasNodeAndResource: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "has_node_and_resource".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_node_and_resource" } + } + } + + val isAParentOf: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "is_a_parent_of".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_a_parent_of" } + } + } + + val isDisplayedFolded: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "is_displayed_folded".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_displayed_folded" } + } + } + + val isGreaterThan: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "is_greater_than".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_greater_than" } + } + } + + val isInGroup: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "is_in_group".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_in_group" } + } + } + + val isInsideTree: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "is_inside_tree".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_inside_tree" } + } + } + + val isNetworkMaster: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "is_network_master".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_network_master" } + } + } + + val isPhysicsProcessing: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "is_physics_processing".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_physics_processing" } + } + } + + val isPhysicsProcessingInternal: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "is_physics_processing_internal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_physics_processing_internal" + } + } + } + + val isProcessing: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "is_processing".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_processing" } + } + } + + val isProcessingInput: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "is_processing_input".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_processing_input" } + } + } + + val isProcessingInternal: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "is_processing_internal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_processing_internal" } + } + } + + val isProcessingUnhandledInput: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "is_processing_unhandled_input".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_processing_unhandled_input" + } + } + } + + val isProcessingUnhandledKeyInput: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "is_processing_unhandled_key_input".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_processing_unhandled_key_input" } + } + } + + val moveChild: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "move_child".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method move_child" } + } + } + + val printStrayNodes: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "print_stray_nodes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method print_stray_nodes" } + } + } + + val printTree: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "print_tree".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method print_tree" } + } + } + + val printTreePretty: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "print_tree_pretty".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method print_tree_pretty" } + } + } + + val propagateCall: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "propagate_call".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method propagate_call" } + } + } + + val propagateNotification: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "propagate_notification".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method propagate_notification" } + } + } + + val queueFree: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "queue_free".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method queue_free" } + } + } + + val raise: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "raise".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method raise" } + } + } + + val removeAndSkip: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "remove_and_skip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_and_skip" } + } + } + + val removeChild: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "remove_child".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_child" } + } + } + + val removeFromGroup: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "remove_from_group".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_from_group" } + } + } + + val replaceBy: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "replace_by".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method replace_by" } + } + } + + val requestReady: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "request_ready".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method request_ready" } + } + } + + val rpc: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "rpc".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rpc" } + } + } + + val rpcConfig: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "rpc_config".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rpc_config" } + } + } + + val rpcId: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "rpc_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rpc_id" } + } + } + + val rpcUnreliable: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "rpc_unreliable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rpc_unreliable" } + } + } + + val rpcUnreliableId: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "rpc_unreliable_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rpc_unreliable_id" } + } + } + + val rset: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "rset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rset" } + } + } + + val rsetConfig: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "rset_config".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rset_config" } + } + } + + val rsetId: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "rset_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rset_id" } + } + } + + val rsetUnreliable: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "rset_unreliable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rset_unreliable" } + } + } + + val rsetUnreliableId: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "rset_unreliable_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rset_unreliable_id" } + } + } + + val setCustomMultiplayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "set_custom_multiplayer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_custom_multiplayer" } + } + } + + val setDisplayFolded: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "set_display_folded".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_display_folded" } + } + } + + val setFilename: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "set_filename".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_filename" } + } + } + + val setName: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "set_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_name" } + } + } + + val setNetworkMaster: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "set_network_master".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_network_master" } + } + } + + val setOwner: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "set_owner".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_owner" } + } + } + + val setPauseMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "set_pause_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pause_mode" } + } + } + + val setPhysicsProcess: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "set_physics_process".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_physics_process" } + } + } + + val setPhysicsProcessInternal: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "set_physics_process_internal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_physics_process_internal" } + } + } + + val setProcess: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "set_process".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_process" } + } + } + + val setProcessInput: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "set_process_input".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_process_input" } + } + } + + val setProcessInternal: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "set_process_internal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_process_internal" } + } + } + + val setProcessPriority: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "set_process_priority".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_process_priority" } + } + } + + val setProcessUnhandledInput: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "set_process_unhandled_input".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_process_unhandled_input" } + } + } + + val setProcessUnhandledKeyInput: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "set_process_unhandled_key_input".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_process_unhandled_key_input" } + } + } + + val setSceneInstanceLoadPlaceholder: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "set_scene_instance_load_placeholder".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_scene_instance_load_placeholder" } + } + } + + val updateConfigurationWarning: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node".cstr.ptr, + "update_configuration_warning".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method update_configuration_warning" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Node2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Node2D.kt index 0d984f08..4c1004db 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Node2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Node2D.kt @@ -489,203 +489,270 @@ open class Node2D( * Container for method_bind pointers for Node2D */ private object __method_bind { - val applyScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "apply_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method apply_scale" } - } - val getAngleTo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "get_angle_to".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_angle_to" } - } - val getGlobalPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "get_global_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_global_position" } - } - val getGlobalRotation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "get_global_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_global_rotation" } - } - val getGlobalRotationDegrees: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "get_global_rotation_degrees".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_global_rotation_degrees" } - } - val getGlobalScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "get_global_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_global_scale" } - } - val getPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "get_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_position" } - } - val getRelativeTransformToParent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "get_relative_transform_to_parent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_relative_transform_to_parent" } - } - val getRotation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "get_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rotation" } - } - val getRotationDegrees: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "get_rotation_degrees".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rotation_degrees" } - } - val getScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "get_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_scale" } - } - val getZIndex: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "get_z_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_z_index" } - } - val globalTranslate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "global_translate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method global_translate" } - } - val isZRelative: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "is_z_relative".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_z_relative" } - } - val lookAt: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "look_at".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method look_at" } - } - val moveLocalX: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "move_local_x".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method move_local_x" } - } - val moveLocalY: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "move_local_y".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method move_local_y" } - } - val rotate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "rotate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rotate" } - } - val setGlobalPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "set_global_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_global_position" } - } - val setGlobalRotation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "set_global_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_global_rotation" } - } - val setGlobalRotationDegrees: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "set_global_rotation_degrees".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_global_rotation_degrees" } - } - val setGlobalScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "set_global_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_global_scale" } - } - val setGlobalTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "set_global_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_global_transform" } - } - val setPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "set_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_position" } - } - val setRotation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "set_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rotation" } - } - val setRotationDegrees: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "set_rotation_degrees".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rotation_degrees" } - } - val setScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "set_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_scale" } - } - val setTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_transform" } - } - val setZAsRelative: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "set_z_as_relative".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_z_as_relative" } - } - val setZIndex: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "set_z_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_z_index" } - } - val toGlobal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "to_global".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method to_global" } - } - val toLocal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "to_local".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method to_local" } - } - val translate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, - "translate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method translate" } - }} + val applyScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "apply_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method apply_scale" } + } + } + + val getAngleTo: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "get_angle_to".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_angle_to" } + } + } + + val getGlobalPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "get_global_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_global_position" } + } + } + + val getGlobalRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "get_global_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_global_rotation" } + } + } + + val getGlobalRotationDegrees: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "get_global_rotation_degrees".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_global_rotation_degrees" } + } + } + + val getGlobalScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "get_global_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_global_scale" } + } + } + + val getPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "get_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_position" } + } + } + + val getRelativeTransformToParent: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "get_relative_transform_to_parent".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_relative_transform_to_parent" } + } + } + + val getRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "get_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rotation" } + } + } + + val getRotationDegrees: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "get_rotation_degrees".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rotation_degrees" } + } + } + + val getScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "get_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_scale" } + } + } + + val getZIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "get_z_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_z_index" } + } + } + + val globalTranslate: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "global_translate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method global_translate" } + } + } + + val isZRelative: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "is_z_relative".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_z_relative" } + } + } + + val lookAt: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "look_at".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method look_at" } + } + } + + val moveLocalX: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "move_local_x".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method move_local_x" } + } + } + + val moveLocalY: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "move_local_y".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method move_local_y" } + } + } + + val rotate: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "rotate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rotate" } + } + } + + val setGlobalPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "set_global_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_global_position" } + } + } + + val setGlobalRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "set_global_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_global_rotation" } + } + } + + val setGlobalRotationDegrees: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "set_global_rotation_degrees".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_global_rotation_degrees" } + } + } + + val setGlobalScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "set_global_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_global_scale" } + } + } + + val setGlobalTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "set_global_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_global_transform" } + } + } + + val setPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "set_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_position" } + } + } + + val setRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "set_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rotation" } + } + } + + val setRotationDegrees: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "set_rotation_degrees".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rotation_degrees" } + } + } + + val setScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "set_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_scale" } + } + } + + val setTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_transform" } + } + } + + val setZAsRelative: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "set_z_as_relative".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_z_as_relative" } + } + } + + val setZIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "set_z_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_z_index" } + } + } + + val toGlobal: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "to_global".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method to_global" } + } + } + + val toLocal: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "to_local".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method to_local" } + } + } + + val translate: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Node2D".cstr.ptr, + "translate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method translate" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/NoiseTexture.kt b/godot-kotlin/src/nativeGen/kotlin/godot/NoiseTexture.kt index fecc3418..8bf47cb6 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/NoiseTexture.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/NoiseTexture.kt @@ -198,75 +198,95 @@ open class NoiseTexture( * Container for method_bind pointers for NoiseTexture */ private object __method_bind { - val getBumpStrength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, - "get_bump_strength".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bump_strength" } - } - val getNoise: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, - "get_noise".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_noise" } - } - val getSeamless: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, - "get_seamless".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_seamless" } - } - val isNormalmap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, - "is_normalmap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_normalmap" } - } - val setAsNormalmap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, - "set_as_normalmap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_as_normalmap" } - } - val setBumpStrength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, - "set_bump_strength".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bump_strength" } - } - val setHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, - "set_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_height" } - } - val setNoise: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, - "set_noise".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_noise" } - } - val setSeamless: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, - "set_seamless".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_seamless" } - } - val setWidth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, - "set_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_width" } - }} + val getBumpStrength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, + "get_bump_strength".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bump_strength" } + } + } + + val getNoise: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, + "get_noise".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_noise" } + } + } + + val getSeamless: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, + "get_seamless".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_seamless" } + } + } + + val isNormalmap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, + "is_normalmap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_normalmap" } + } + } + + val setAsNormalmap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, + "set_as_normalmap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_as_normalmap" } + } + } + + val setBumpStrength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, + "set_bump_strength".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bump_strength" } + } + } + + val setHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, + "set_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_height" } + } + } + + val setNoise: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, + "set_noise".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_noise" } + } + } + + val setSeamless: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, + "set_seamless".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_seamless" } + } + } + + val setWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("NoiseTexture".cstr.ptr, + "set_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_width" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/OS.kt b/godot-kotlin/src/nativeGen/kotlin/godot/OS.kt index d1492436..af9d3c97 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/OS.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/OS.kt @@ -1524,833 +1524,1109 @@ open class OSInternal( * Container for method_bind pointers for OS */ private object __method_bind { - val alert: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "alert".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method alert" } - } - val canDraw: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "can_draw".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method can_draw" } - } - val canUseThreads: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "can_use_threads".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method can_use_threads" } - } - val centerWindow: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "center_window".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method center_window" } - } - val closeMidiInputs: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "close_midi_inputs".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method close_midi_inputs" } - } - val delayMsec: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "delay_msec".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method delay_msec" } - } - val delayUsec: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "delay_usec".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method delay_usec" } - } - val dumpMemoryToFile: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "dump_memory_to_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method dump_memory_to_file" } - } - val dumpResourcesToFile: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "dump_resources_to_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method dump_resources_to_file" } - } - val execute: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "execute".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method execute" } - } - val findScancodeFromString: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "find_scancode_from_string".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method find_scancode_from_string" } - } - val getAudioDriverCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_audio_driver_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_audio_driver_count" } - } - val getAudioDriverName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_audio_driver_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_audio_driver_name" } - } - val getBorderlessWindow: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_borderless_window".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_borderless_window" } - } - val getClipboard: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_clipboard".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_clipboard" } - } - val getCmdlineArgs: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_cmdline_args".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cmdline_args" } - } - val getConnectedMidiInputs: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_connected_midi_inputs".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connected_midi_inputs" } - } - val getCurrentScreen: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_current_screen".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_screen" } - } - val getCurrentVideoDriver: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_current_video_driver".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_video_driver" } - } - val getDate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_date".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_date" } - } - val getDatetime: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_datetime".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_datetime" } - } - val getDatetimeFromUnixTime: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_datetime_from_unix_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_datetime_from_unix_time" } - } - val getDynamicMemoryUsage: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_dynamic_memory_usage".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_dynamic_memory_usage" } - } - val getEnvironment: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_environment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_environment" } - } - val getExecutablePath: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_executable_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_executable_path" } - } - val getExitCode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_exit_code".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_exit_code" } - } - val getGrantedPermissions: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_granted_permissions".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_granted_permissions" } - } - val getImeSelection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_ime_selection".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ime_selection" } - } - val getImeText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_ime_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ime_text" } - } - val getLatinKeyboardVariant: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_latin_keyboard_variant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_latin_keyboard_variant" } - } - val getLocale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_locale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_locale" } - } - val getLowProcessorUsageModeSleepUsec: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_low_processor_usage_mode_sleep_usec".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method get_low_processor_usage_mode_sleep_usec" } - } - val getMaxWindowSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_max_window_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_max_window_size" } - } - val getMinWindowSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_min_window_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_min_window_size" } - } - val getModelName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_model_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_model_name" } - } - val getName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_name" } - } - val getPowerPercentLeft: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_power_percent_left".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_power_percent_left" } - } - val getPowerSecondsLeft: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_power_seconds_left".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_power_seconds_left" } - } - val getPowerState: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_power_state".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_power_state" } - } - val getProcessId: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_process_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_process_id" } - } - val getProcessorCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_processor_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_processor_count" } - } - val getRealWindowSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_real_window_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_real_window_size" } - } - val getScancodeString: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_scancode_string".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_scancode_string" } - } - val getScreenCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_screen_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_screen_count" } - } - val getScreenDpi: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_screen_dpi".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_screen_dpi" } - } - val getScreenOrientation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_screen_orientation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_screen_orientation" } - } - val getScreenPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_screen_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_screen_position" } - } - val getScreenSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_screen_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_screen_size" } - } - val getSplashTickMsec: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_splash_tick_msec".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_splash_tick_msec" } - } - val getStaticMemoryPeakUsage: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_static_memory_peak_usage".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_static_memory_peak_usage" } - } - val getStaticMemoryUsage: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_static_memory_usage".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_static_memory_usage" } - } - val getSystemDir: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_system_dir".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_system_dir" } - } - val getSystemTimeMsecs: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_system_time_msecs".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_system_time_msecs" } - } - val getSystemTimeSecs: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_system_time_secs".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_system_time_secs" } - } - val getTicksMsec: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_ticks_msec".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ticks_msec" } - } - val getTicksUsec: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_ticks_usec".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ticks_usec" } - } - val getTime: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_time" } - } - val getTimeZoneInfo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_time_zone_info".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_time_zone_info" } - } - val getUniqueId: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_unique_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_unique_id" } - } - val getUnixTime: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_unix_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_unix_time" } - } - val getUnixTimeFromDatetime: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_unix_time_from_datetime".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_unix_time_from_datetime" } - } - val getUserDataDir: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_user_data_dir".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_user_data_dir" } - } - val getVideoDriverCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_video_driver_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_video_driver_count" } - } - val getVideoDriverName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_video_driver_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_video_driver_name" } - } - val getVirtualKeyboardHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_virtual_keyboard_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_virtual_keyboard_height" } - } - val getWindowPerPixelTransparencyEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_window_per_pixel_transparency_enabled".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method get_window_per_pixel_transparency_enabled" } - } - val getWindowPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_window_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_window_position" } - } - val getWindowSafeArea: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_window_safe_area".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_window_safe_area" } - } - val getWindowSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "get_window_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_window_size" } - } - val globalMenuAddItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "global_menu_add_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method global_menu_add_item" } - } - val globalMenuAddSeparator: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "global_menu_add_separator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method global_menu_add_separator" } - } - val globalMenuClear: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "global_menu_clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method global_menu_clear" } - } - val globalMenuRemoveItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "global_menu_remove_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method global_menu_remove_item" } - } - val hasEnvironment: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "has_environment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_environment" } - } - val hasFeature: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "has_feature".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_feature" } - } - val hasTouchscreenUiHint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "has_touchscreen_ui_hint".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_touchscreen_ui_hint" } - } - val hasVirtualKeyboard: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "has_virtual_keyboard".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_virtual_keyboard" } - } - val hideVirtualKeyboard: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "hide_virtual_keyboard".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method hide_virtual_keyboard" } - } - val isDebugBuild: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "is_debug_build".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_debug_build" } - } - val isInLowProcessorUsageMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "is_in_low_processor_usage_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_in_low_processor_usage_mode" } - } - val isKeepScreenOn: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "is_keep_screen_on".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_keep_screen_on" } - } - val isOkLeftAndCancelRight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "is_ok_left_and_cancel_right".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_ok_left_and_cancel_right" } - } - val isScancodeUnicode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "is_scancode_unicode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_scancode_unicode" } - } - val isStdoutVerbose: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "is_stdout_verbose".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_stdout_verbose" } - } - val isUserfsPersistent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "is_userfs_persistent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_userfs_persistent" } - } - val isVsyncEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "is_vsync_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_vsync_enabled" } - } - val isVsyncViaCompositorEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "is_vsync_via_compositor_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_vsync_via_compositor_enabled" } - } - val isWindowAlwaysOnTop: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "is_window_always_on_top".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_window_always_on_top" } - } - val isWindowFocused: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "is_window_focused".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_window_focused" } - } - val isWindowFullscreen: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "is_window_fullscreen".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_window_fullscreen" } - } - val isWindowMaximized: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "is_window_maximized".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_window_maximized" } - } - val isWindowMinimized: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "is_window_minimized".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_window_minimized" } - } - val isWindowResizable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "is_window_resizable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_window_resizable" } - } - val kill: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "kill".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method kill" } - } - val moveWindowToForeground: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "move_window_to_foreground".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method move_window_to_foreground" } - } - val nativeVideoIsPlaying: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "native_video_is_playing".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method native_video_is_playing" } - } - val nativeVideoPause: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "native_video_pause".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method native_video_pause" } - } - val nativeVideoPlay: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "native_video_play".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method native_video_play" } - } - val nativeVideoStop: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "native_video_stop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method native_video_stop" } - } - val nativeVideoUnpause: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "native_video_unpause".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method native_video_unpause" } - } - val openMidiInputs: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "open_midi_inputs".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method open_midi_inputs" } - } - val printAllResources: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "print_all_resources".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method print_all_resources" } - } - val printAllTexturesBySize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "print_all_textures_by_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method print_all_textures_by_size" } - } - val printResourcesByType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "print_resources_by_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method print_resources_by_type" } - } - val printResourcesInUse: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "print_resources_in_use".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method print_resources_in_use" } - } - val requestAttention: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "request_attention".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method request_attention" } - } - val requestPermission: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "request_permission".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method request_permission" } - } - val requestPermissions: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "request_permissions".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method request_permissions" } - } - val setBorderlessWindow: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_borderless_window".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_borderless_window" } - } - val setClipboard: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_clipboard".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_clipboard" } - } - val setCurrentScreen: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_current_screen".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_current_screen" } - } - val setExitCode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_exit_code".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_exit_code" } - } - val setIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_icon" } - } - val setImeActive: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_ime_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ime_active" } - } - val setImePosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_ime_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ime_position" } - } - val setKeepScreenOn: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_keep_screen_on".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_keep_screen_on" } - } - val setLowProcessorUsageMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_low_processor_usage_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_low_processor_usage_mode" } - } - val setLowProcessorUsageModeSleepUsec: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_low_processor_usage_mode_sleep_usec".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method set_low_processor_usage_mode_sleep_usec" } - } - val setMaxWindowSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_max_window_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_max_window_size" } - } - val setMinWindowSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_min_window_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_min_window_size" } - } - val setNativeIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_native_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_native_icon" } - } - val setScreenOrientation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_screen_orientation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_screen_orientation" } - } - val setThreadName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_thread_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_thread_name" } - } - val setUseFileAccessSaveAndSwap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_use_file_access_save_and_swap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_file_access_save_and_swap" + val alert: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "alert".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method alert" } + } + } + + val canDraw: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "can_draw".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method can_draw" } + } + } + + val canUseThreads: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "can_use_threads".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method can_use_threads" } + } + } + + val centerWindow: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "center_window".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method center_window" } + } + } + + val closeMidiInputs: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "close_midi_inputs".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method close_midi_inputs" } + } + } + + val delayMsec: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "delay_msec".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method delay_msec" } + } + } + + val delayUsec: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "delay_usec".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method delay_usec" } + } + } + + val dumpMemoryToFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "dump_memory_to_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method dump_memory_to_file" } + } + } + + val dumpResourcesToFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "dump_resources_to_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method dump_resources_to_file" } + } + } + + val execute: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "execute".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method execute" } + } + } + + val findScancodeFromString: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "find_scancode_from_string".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method find_scancode_from_string" } + } + } + + val getAudioDriverCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_audio_driver_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_audio_driver_count" } + } + } + + val getAudioDriverName: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_audio_driver_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_audio_driver_name" } + } + } + + val getBorderlessWindow: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_borderless_window".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_borderless_window" } + } + } + + val getClipboard: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_clipboard".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_clipboard" } + } + } + + val getCmdlineArgs: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_cmdline_args".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cmdline_args" } + } + } + + val getConnectedMidiInputs: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_connected_midi_inputs".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connected_midi_inputs" } + } + } + + val getCurrentScreen: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_current_screen".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_screen" } + } + } + + val getCurrentVideoDriver: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_current_video_driver".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_video_driver" } + } + } + + val getDate: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_date".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_date" } + } + } + + val getDatetime: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_datetime".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_datetime" } + } + } + + val getDatetimeFromUnixTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_datetime_from_unix_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_datetime_from_unix_time" } + } + } + + val getDynamicMemoryUsage: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_dynamic_memory_usage".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_dynamic_memory_usage" } + } + } + + val getEnvironment: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_environment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_environment" } + } + } + + val getExecutablePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_executable_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_executable_path" } + } + } + + val getExitCode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_exit_code".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_exit_code" } + } + } + + val getGrantedPermissions: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_granted_permissions".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_granted_permissions" } + } + } + + val getImeSelection: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_ime_selection".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ime_selection" } + } + } + + val getImeText: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_ime_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ime_text" } + } + } + + val getLatinKeyboardVariant: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_latin_keyboard_variant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_latin_keyboard_variant" } + } + } + + val getLocale: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_locale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_locale" } + } + } + + val getLowProcessorUsageModeSleepUsec: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_low_processor_usage_mode_sleep_usec".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_low_processor_usage_mode_sleep_usec" } + } + } + + val getMaxWindowSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_max_window_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_max_window_size" } + } + } + + val getMinWindowSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_min_window_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_min_window_size" } + } + } + + val getModelName: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_model_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_model_name" } + } + } + + val getName: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_name" } + } + } + + val getPowerPercentLeft: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_power_percent_left".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_power_percent_left" } + } + } + + val getPowerSecondsLeft: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_power_seconds_left".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_power_seconds_left" } + } + } + + val getPowerState: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_power_state".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_power_state" } + } + } + + val getProcessId: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_process_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_process_id" } + } + } + + val getProcessorCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_processor_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_processor_count" } + } + } + + val getRealWindowSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_real_window_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_real_window_size" } + } + } + + val getScancodeString: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_scancode_string".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_scancode_string" } + } + } + + val getScreenCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_screen_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_screen_count" } + } + } + + val getScreenDpi: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_screen_dpi".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_screen_dpi" } + } + } + + val getScreenOrientation: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_screen_orientation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_screen_orientation" } + } + } + + val getScreenPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_screen_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_screen_position" } + } + } + + val getScreenSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_screen_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_screen_size" } + } + } + + val getSplashTickMsec: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_splash_tick_msec".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_splash_tick_msec" } + } + } + + val getStaticMemoryPeakUsage: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_static_memory_peak_usage".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_static_memory_peak_usage" } + } + } + + val getStaticMemoryUsage: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_static_memory_usage".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_static_memory_usage" } + } + } + + val getSystemDir: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_system_dir".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_system_dir" } + } + } + + val getSystemTimeMsecs: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_system_time_msecs".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_system_time_msecs" } + } + } + + val getSystemTimeSecs: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_system_time_secs".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_system_time_secs" } + } + } + + val getTicksMsec: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_ticks_msec".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ticks_msec" } + } + } + + val getTicksUsec: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_ticks_usec".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ticks_usec" } + } + } + + val getTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_time" } } - } - val setUseVsync: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_use_vsync".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_vsync" } - } - val setVsyncViaCompositor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_vsync_via_compositor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_vsync_via_compositor" } - } - val setWindowAlwaysOnTop: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_window_always_on_top".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_window_always_on_top" } - } - val setWindowFullscreen: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_window_fullscreen".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_window_fullscreen" } - } - val setWindowMaximized: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_window_maximized".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_window_maximized" } - } - val setWindowMinimized: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_window_minimized".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_window_minimized" } - } - val setWindowPerPixelTransparencyEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_window_per_pixel_transparency_enabled".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method set_window_per_pixel_transparency_enabled" } - } - val setWindowPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_window_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_window_position" } - } - val setWindowResizable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_window_resizable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_window_resizable" } - } - val setWindowSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_window_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_window_size" } - } - val setWindowTitle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "set_window_title".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_window_title" } - } - val shellOpen: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "shell_open".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shell_open" } - } - val showVirtualKeyboard: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, - "show_virtual_keyboard".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method show_virtual_keyboard" } - }} + } + + val getTimeZoneInfo: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_time_zone_info".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_time_zone_info" } + } + } + + val getUniqueId: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_unique_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_unique_id" } + } + } + + val getUnixTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_unix_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_unix_time" } + } + } + + val getUnixTimeFromDatetime: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_unix_time_from_datetime".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_unix_time_from_datetime" } + } + } + + val getUserDataDir: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_user_data_dir".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_user_data_dir" } + } + } + + val getVideoDriverCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_video_driver_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_video_driver_count" } + } + } + + val getVideoDriverName: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_video_driver_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_video_driver_name" } + } + } + + val getVirtualKeyboardHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_virtual_keyboard_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_virtual_keyboard_height" } + } + } + + val getWindowPerPixelTransparencyEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_window_per_pixel_transparency_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_window_per_pixel_transparency_enabled" } + } + } + + val getWindowPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_window_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_window_position" } + } + } + + val getWindowSafeArea: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_window_safe_area".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_window_safe_area" } + } + } + + val getWindowSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "get_window_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_window_size" } + } + } + + val globalMenuAddItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "global_menu_add_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method global_menu_add_item" } + } + } + + val globalMenuAddSeparator: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "global_menu_add_separator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method global_menu_add_separator" } + } + } + + val globalMenuClear: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "global_menu_clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method global_menu_clear" } + } + } + + val globalMenuRemoveItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "global_menu_remove_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method global_menu_remove_item" } + } + } + + val hasEnvironment: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "has_environment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_environment" } + } + } + + val hasFeature: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "has_feature".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_feature" } + } + } + + val hasTouchscreenUiHint: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "has_touchscreen_ui_hint".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_touchscreen_ui_hint" } + } + } + + val hasVirtualKeyboard: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "has_virtual_keyboard".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_virtual_keyboard" } + } + } + + val hideVirtualKeyboard: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "hide_virtual_keyboard".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method hide_virtual_keyboard" } + } + } + + val isDebugBuild: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "is_debug_build".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_debug_build" } + } + } + + val isInLowProcessorUsageMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "is_in_low_processor_usage_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_in_low_processor_usage_mode" + } + } + } + + val isKeepScreenOn: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "is_keep_screen_on".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_keep_screen_on" } + } + } + + val isOkLeftAndCancelRight: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "is_ok_left_and_cancel_right".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_ok_left_and_cancel_right" } + } + } + + val isScancodeUnicode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "is_scancode_unicode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_scancode_unicode" } + } + } + + val isStdoutVerbose: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "is_stdout_verbose".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_stdout_verbose" } + } + } + + val isUserfsPersistent: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "is_userfs_persistent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_userfs_persistent" } + } + } + + val isVsyncEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "is_vsync_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_vsync_enabled" } + } + } + + val isVsyncViaCompositorEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "is_vsync_via_compositor_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_vsync_via_compositor_enabled" } + } + } + + val isWindowAlwaysOnTop: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "is_window_always_on_top".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_window_always_on_top" } + } + } + + val isWindowFocused: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "is_window_focused".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_window_focused" } + } + } + + val isWindowFullscreen: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "is_window_fullscreen".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_window_fullscreen" } + } + } + + val isWindowMaximized: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "is_window_maximized".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_window_maximized" } + } + } + + val isWindowMinimized: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "is_window_minimized".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_window_minimized" } + } + } + + val isWindowResizable: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "is_window_resizable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_window_resizable" } + } + } + + val kill: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "kill".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method kill" } + } + } + + val moveWindowToForeground: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "move_window_to_foreground".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method move_window_to_foreground" } + } + } + + val nativeVideoIsPlaying: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "native_video_is_playing".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method native_video_is_playing" } + } + } + + val nativeVideoPause: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "native_video_pause".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method native_video_pause" } + } + } + + val nativeVideoPlay: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "native_video_play".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method native_video_play" } + } + } + + val nativeVideoStop: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "native_video_stop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method native_video_stop" } + } + } + + val nativeVideoUnpause: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "native_video_unpause".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method native_video_unpause" } + } + } + + val openMidiInputs: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "open_midi_inputs".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method open_midi_inputs" } + } + } + + val printAllResources: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "print_all_resources".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method print_all_resources" } + } + } + + val printAllTexturesBySize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "print_all_textures_by_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method print_all_textures_by_size" } + } + } + + val printResourcesByType: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "print_resources_by_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method print_resources_by_type" } + } + } + + val printResourcesInUse: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "print_resources_in_use".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method print_resources_in_use" } + } + } + + val requestAttention: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "request_attention".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method request_attention" } + } + } + + val requestPermission: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "request_permission".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method request_permission" } + } + } + + val requestPermissions: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "request_permissions".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method request_permissions" } + } + } + + val setBorderlessWindow: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_borderless_window".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_borderless_window" } + } + } + + val setClipboard: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_clipboard".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_clipboard" } + } + } + + val setCurrentScreen: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_current_screen".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_current_screen" } + } + } + + val setExitCode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_exit_code".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_exit_code" } + } + } + + val setIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_icon" } + } + } + + val setImeActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_ime_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ime_active" } + } + } + + val setImePosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_ime_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ime_position" } + } + } + + val setKeepScreenOn: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_keep_screen_on".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_keep_screen_on" } + } + } + + val setLowProcessorUsageMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_low_processor_usage_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_low_processor_usage_mode" } + } + } + + val setLowProcessorUsageModeSleepUsec: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_low_processor_usage_mode_sleep_usec".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_low_processor_usage_mode_sleep_usec" } + } + } + + val setMaxWindowSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_max_window_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_max_window_size" } + } + } + + val setMinWindowSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_min_window_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_min_window_size" } + } + } + + val setNativeIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_native_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_native_icon" } + } + } + + val setScreenOrientation: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_screen_orientation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_screen_orientation" } + } + } + + val setThreadName: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_thread_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_thread_name" } + } + } + + val setUseFileAccessSaveAndSwap: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_use_file_access_save_and_swap".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_use_file_access_save_and_swap" } + } + } + + val setUseVsync: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_use_vsync".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_vsync" } + } + } + + val setVsyncViaCompositor: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_vsync_via_compositor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_vsync_via_compositor" } + } + } + + val setWindowAlwaysOnTop: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_window_always_on_top".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_window_always_on_top" } + } + } + + val setWindowFullscreen: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_window_fullscreen".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_window_fullscreen" } + } + } + + val setWindowMaximized: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_window_maximized".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_window_maximized" } + } + } + + val setWindowMinimized: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_window_minimized".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_window_minimized" } + } + } + + val setWindowPerPixelTransparencyEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_window_per_pixel_transparency_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_window_per_pixel_transparency_enabled" } + } + } + + val setWindowPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_window_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_window_position" } + } + } + + val setWindowResizable: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_window_resizable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_window_resizable" } + } + } + + val setWindowSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_window_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_window_size" } + } + } + + val setWindowTitle: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "set_window_title".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_window_title" } + } + } + + val shellOpen: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "shell_open".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shell_open" } + } + } + + val showVirtualKeyboard: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_OS".cstr.ptr, + "show_virtual_keyboard".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method show_virtual_keyboard" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Object.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Object.kt index 69270510..8f7ddea9 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Object.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Object.kt @@ -888,245 +888,325 @@ open class Object( * Container for method_bind pointers for Object */ private object __method_bind { - val addUserSignal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "add_user_signal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_user_signal" } - } - val call: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "call".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method call" } - } - val callDeferred: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "call_deferred".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method call_deferred" } - } - val callv: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "callv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method callv" } - } - val canTranslateMessages: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "can_translate_messages".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method can_translate_messages" } - } - val connect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "connect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method connect" } - } - val disconnect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "disconnect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method disconnect" } - } - val emitSignal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "emit_signal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method emit_signal" } - } - val free: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "free".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method free" } - } - val get: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "get".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get" } - } - val getClass: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "get_class".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_class" } - } - val getIncomingConnections: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "get_incoming_connections".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_incoming_connections" } - } - val getIndexed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "get_indexed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_indexed" } - } - val getInstanceId: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "get_instance_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_instance_id" } - } - val getMeta: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "get_meta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_meta" } - } - val getMetaList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "get_meta_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_meta_list" } - } - val getMethodList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "get_method_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_method_list" } - } - val getPropertyList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "get_property_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_property_list" } - } - val getScript: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "get_script".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_script" } - } - val getSignalConnectionList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "get_signal_connection_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_signal_connection_list" } - } - val getSignalList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "get_signal_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_signal_list" } - } - val hasMeta: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "has_meta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_meta" } - } - val hasMethod: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "has_method".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_method" } - } - val hasUserSignal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "has_user_signal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_user_signal" } - } - val isBlockingSignals: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "is_blocking_signals".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_blocking_signals" } - } - val isClass: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "is_class".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_class" } - } - val isConnected: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "is_connected".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_connected" } - } - val isQueuedForDeletion: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "is_queued_for_deletion".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_queued_for_deletion" } - } - val notification: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "notification".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method notification" } - } - val propertyListChangedNotify: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "property_list_changed_notify".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method property_list_changed_notify" } - } - val removeMeta: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "remove_meta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_meta" } - } - val set: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "set".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set" } - } - val setBlockSignals: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "set_block_signals".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_block_signals" } - } - val setDeferred: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "set_deferred".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_deferred" } - } - val setIndexed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "set_indexed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_indexed" } - } - val setMessageTranslation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "set_message_translation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_message_translation" } - } - val setMeta: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "set_meta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_meta" } - } - val setScript: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "set_script".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_script" } - } - val toString: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "to_string".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method to_string" } - } - val tr: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, - "tr".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tr" } - }} + val addUserSignal: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "add_user_signal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_user_signal" } + } + } + + val call: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "call".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method call" } + } + } + + val callDeferred: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "call_deferred".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method call_deferred" } + } + } + + val callv: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "callv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method callv" } + } + } + + val canTranslateMessages: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "can_translate_messages".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method can_translate_messages" } + } + } + + val connect: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "connect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method connect" } + } + } + + val disconnect: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "disconnect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method disconnect" } + } + } + + val emitSignal: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "emit_signal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method emit_signal" } + } + } + + val free: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "free".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method free" } + } + } + + val get: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "get".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get" } + } + } + + val getClass: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "get_class".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_class" } + } + } + + val getIncomingConnections: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "get_incoming_connections".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_incoming_connections" } + } + } + + val getIndexed: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "get_indexed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_indexed" } + } + } + + val getInstanceId: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "get_instance_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_instance_id" } + } + } + + val getMeta: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "get_meta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_meta" } + } + } + + val getMetaList: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "get_meta_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_meta_list" } + } + } + + val getMethodList: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "get_method_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_method_list" } + } + } + + val getPropertyList: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "get_property_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_property_list" } + } + } + + val getScript: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "get_script".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_script" } + } + } + + val getSignalConnectionList: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "get_signal_connection_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_signal_connection_list" } + } + } + + val getSignalList: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "get_signal_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_signal_list" } + } + } + + val hasMeta: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "has_meta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_meta" } + } + } + + val hasMethod: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "has_method".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_method" } + } + } + + val hasUserSignal: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "has_user_signal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_user_signal" } + } + } + + val isBlockingSignals: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "is_blocking_signals".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_blocking_signals" } + } + } + + val isClass: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "is_class".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_class" } + } + } + + val isConnected: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "is_connected".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_connected" } + } + } + + val isQueuedForDeletion: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "is_queued_for_deletion".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_queued_for_deletion" } + } + } + + val notification: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "notification".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method notification" } + } + } + + val propertyListChangedNotify: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "property_list_changed_notify".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method property_list_changed_notify" } + } + } + + val removeMeta: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "remove_meta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_meta" } + } + } + + val set: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "set".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set" } + } + } + + val setBlockSignals: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "set_block_signals".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_block_signals" } + } + } + + val setDeferred: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "set_deferred".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_deferred" } + } + } + + val setIndexed: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "set_indexed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_indexed" } + } + } + + val setMessageTranslation: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "set_message_translation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_message_translation" } + } + } + + val setMeta: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "set_meta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_meta" } + } + } + + val setScript: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "set_script".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_script" } + } + } + + val toString: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "to_string".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method to_string" } + } + } + + val tr: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Object".cstr.ptr, + "tr".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tr" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/OccluderPolygon2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/OccluderPolygon2D.kt index dcdbd73e..1d6c590e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/OccluderPolygon2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/OccluderPolygon2D.kt @@ -158,47 +158,59 @@ open class OccluderPolygon2D( * Container for method_bind pointers for OccluderPolygon2D */ private object __method_bind { - val getCullMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OccluderPolygon2D".cstr.ptr, - "get_cull_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cull_mode" } - } - val getPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OccluderPolygon2D".cstr.ptr, - "get_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_polygon" } - } - val isClosed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OccluderPolygon2D".cstr.ptr, - "is_closed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_closed" } - } - val setClosed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OccluderPolygon2D".cstr.ptr, - "set_closed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_closed" } - } - val setCullMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OccluderPolygon2D".cstr.ptr, - "set_cull_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cull_mode" } - } - val setPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OccluderPolygon2D".cstr.ptr, - "set_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_polygon" } - }} + val getCullMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OccluderPolygon2D".cstr.ptr, + "get_cull_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cull_mode" } + } + } + + val getPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OccluderPolygon2D".cstr.ptr, + "get_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_polygon" } + } + } + + val isClosed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OccluderPolygon2D".cstr.ptr, + "is_closed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_closed" } + } + } + + val setClosed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OccluderPolygon2D".cstr.ptr, + "set_closed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_closed" } + } + } + + val setCullMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OccluderPolygon2D".cstr.ptr, + "set_cull_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cull_mode" } + } + } + + val setPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OccluderPolygon2D".cstr.ptr, + "set_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_polygon" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/OmniLight.kt b/godot-kotlin/src/nativeGen/kotlin/godot/OmniLight.kt index b39687c7..a7d50bdc 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/OmniLight.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/OmniLight.kt @@ -153,29 +153,41 @@ open class OmniLight( * Container for method_bind pointers for OmniLight */ private object __method_bind { - val getShadowDetail: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OmniLight".cstr.ptr, - "get_shadow_detail".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shadow_detail" } - } - val getShadowMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OmniLight".cstr.ptr, - "get_shadow_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shadow_mode" } - } - val setShadowDetail: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OmniLight".cstr.ptr, - "set_shadow_detail".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shadow_detail" } - } - val setShadowMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OmniLight".cstr.ptr, - "set_shadow_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shadow_mode" } - }} + val getShadowDetail: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OmniLight".cstr.ptr, + "get_shadow_detail".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shadow_detail" } + } + } + + val getShadowMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OmniLight".cstr.ptr, + "get_shadow_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shadow_mode" } + } + } + + val setShadowDetail: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OmniLight".cstr.ptr, + "set_shadow_detail".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shadow_detail" } + } + } + + val setShadowMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OmniLight".cstr.ptr, + "set_shadow_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shadow_mode" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/OpenSimplexNoise.kt b/godot-kotlin/src/nativeGen/kotlin/godot/OpenSimplexNoise.kt index ed14f735..282c6d4e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/OpenSimplexNoise.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/OpenSimplexNoise.kt @@ -285,131 +285,167 @@ open class OpenSimplexNoise( * Container for method_bind pointers for OpenSimplexNoise */ private object __method_bind { - val getImage: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, - "get_image".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_image" } - } - val getLacunarity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, - "get_lacunarity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_lacunarity" } - } - val getNoise1d: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, - "get_noise_1d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_noise_1d" } - } - val getNoise2d: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, - "get_noise_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_noise_2d" } - } - val getNoise2dv: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, - "get_noise_2dv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_noise_2dv" } - } - val getNoise3d: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, - "get_noise_3d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_noise_3d" } - } - val getNoise3dv: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, - "get_noise_3dv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_noise_3dv" } - } - val getNoise4d: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, - "get_noise_4d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_noise_4d" } - } - val getOctaves: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, - "get_octaves".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_octaves" } - } - val getPeriod: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, - "get_period".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_period" } - } - val getPersistence: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, - "get_persistence".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_persistence" } - } - val getSeamlessImage: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, - "get_seamless_image".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_seamless_image" } - } - val getSeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, - "get_seed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_seed" } - } - val setLacunarity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, - "set_lacunarity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_lacunarity" } - } - val setOctaves: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, - "set_octaves".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_octaves" } - } - val setPeriod: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, - "set_period".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_period" } - } - val setPersistence: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, - "set_persistence".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_persistence" } - } - val setSeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, - "set_seed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_seed" } - }} + val getImage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, + "get_image".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_image" } + } + } + + val getLacunarity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, + "get_lacunarity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_lacunarity" } + } + } + + val getNoise1d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, + "get_noise_1d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_noise_1d" } + } + } + + val getNoise2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, + "get_noise_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_noise_2d" } + } + } + + val getNoise2dv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, + "get_noise_2dv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_noise_2dv" } + } + } + + val getNoise3d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, + "get_noise_3d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_noise_3d" } + } + } + + val getNoise3dv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, + "get_noise_3dv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_noise_3dv" } + } + } + + val getNoise4d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, + "get_noise_4d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_noise_4d" } + } + } + + val getOctaves: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, + "get_octaves".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_octaves" } + } + } + + val getPeriod: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, + "get_period".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_period" } + } + } + + val getPersistence: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, + "get_persistence".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_persistence" } + } + } + + val getSeamlessImage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, + "get_seamless_image".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_seamless_image" } + } + } + + val getSeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, + "get_seed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_seed" } + } + } + + val setLacunarity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, + "set_lacunarity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_lacunarity" } + } + } + + val setOctaves: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, + "set_octaves".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_octaves" } + } + } + + val setPeriod: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, + "set_period".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_period" } + } + } + + val setPersistence: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, + "set_persistence".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_persistence" } + } + } + + val setSeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OpenSimplexNoise".cstr.ptr, + "set_seed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_seed" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/OptionButton.kt b/godot-kotlin/src/nativeGen/kotlin/godot/OptionButton.kt index ed51c66c..9e625ae7 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/OptionButton.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/OptionButton.kt @@ -299,159 +299,203 @@ open class OptionButton( * Container for method_bind pointers for OptionButton */ private object __method_bind { - val addIconItem: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "add_icon_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_icon_item" } - } - val addItem: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "add_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_item" } - } - val addSeparator: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "add_separator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_separator" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val getItemCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "get_item_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_count" } - } - val getItemIcon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "get_item_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_icon" } - } - val getItemId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "get_item_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_id" } - } - val getItemIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "get_item_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_index" } - } - val getItemMetadata: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "get_item_metadata".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_metadata" } - } - val getItemText: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "get_item_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_text" } - } - val getPopup: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "get_popup".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_popup" } - } - val getSelected: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "get_selected".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_selected" } - } - val getSelectedId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "get_selected_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_selected_id" } - } - val getSelectedMetadata: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "get_selected_metadata".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_selected_metadata" } - } - val isItemDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "is_item_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_item_disabled" } - } - val removeItem: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "remove_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_item" } - } - val select: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "select".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method select" } - } - val setItemDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "set_item_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_disabled" } - } - val setItemIcon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "set_item_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_icon" } - } - val setItemId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "set_item_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_id" } - } - val setItemMetadata: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "set_item_metadata".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_metadata" } - } - val setItemText: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, - "set_item_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_text" } - }} + val addIconItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "add_icon_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_icon_item" } + } + } + + val addItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "add_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_item" } + } + } + + val addSeparator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "add_separator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_separator" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val getItemCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "get_item_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_count" } + } + } + + val getItemIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "get_item_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_icon" } + } + } + + val getItemId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "get_item_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_id" } + } + } + + val getItemIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "get_item_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_index" } + } + } + + val getItemMetadata: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "get_item_metadata".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_metadata" } + } + } + + val getItemText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "get_item_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_text" } + } + } + + val getPopup: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "get_popup".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_popup" } + } + } + + val getSelected: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "get_selected".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_selected" } + } + } + + val getSelectedId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "get_selected_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_selected_id" } + } + } + + val getSelectedMetadata: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "get_selected_metadata".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_selected_metadata" } + } + } + + val isItemDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "is_item_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_item_disabled" } + } + } + + val removeItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "remove_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_item" } + } + } + + val select: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "select".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method select" } + } + } + + val setItemDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "set_item_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_disabled" } + } + } + + val setItemIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "set_item_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_icon" } + } + } + + val setItemId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "set_item_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_id" } + } + } + + val setItemMetadata: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "set_item_metadata".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_metadata" } + } + } + + val setItemText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("OptionButton".cstr.ptr, + "set_item_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_text" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PCKPacker.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PCKPacker.kt index 79c59007..2ae4a298 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PCKPacker.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PCKPacker.kt @@ -86,23 +86,32 @@ open class PCKPacker( * Container for method_bind pointers for PCKPacker */ private object __method_bind { - val addFile: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PCKPacker".cstr.ptr, - "add_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_file" } - } - val flush: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PCKPacker".cstr.ptr, - "flush".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method flush" } - } - val pckStart: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PCKPacker".cstr.ptr, - "pck_start".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method pck_start" } - }} + val addFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PCKPacker".cstr.ptr, + "add_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_file" } + } + } + + val flush: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PCKPacker".cstr.ptr, + "flush".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method flush" } + } + } + + val pckStart: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PCKPacker".cstr.ptr, + "pck_start".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method pck_start" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PHashTranslation.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PHashTranslation.kt index 6e19e49c..c4fbcc69 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PHashTranslation.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PHashTranslation.kt @@ -55,12 +55,14 @@ open class PHashTranslation( * Container for method_bind pointers for PHashTranslation */ private object __method_bind { - val generate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PHashTranslation".cstr.ptr, - "generate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method generate" } - }} + val generate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PHashTranslation".cstr.ptr, + "generate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method generate" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PackedDataContainer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PackedDataContainer.kt index d3ba7e5b..78a88af2 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PackedDataContainer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PackedDataContainer.kt @@ -91,19 +91,23 @@ open class PackedDataContainer( * Container for method_bind pointers for PackedDataContainer */ private object __method_bind { - val pack: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PackedDataContainer".cstr.ptr, - "pack".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method pack" } - } - val size: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PackedDataContainer".cstr.ptr, - "size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method size" } - }} + val pack: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PackedDataContainer".cstr.ptr, + "pack".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method pack" } + } + } + + val size: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PackedDataContainer".cstr.ptr, + "size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method size" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PackedDataContainerRef.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PackedDataContainerRef.kt index 2f17b8ad..c6824597 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PackedDataContainerRef.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PackedDataContainerRef.kt @@ -69,12 +69,14 @@ open class PackedDataContainerRef( * Container for method_bind pointers for PackedDataContainerRef */ private object __method_bind { - val size: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PackedDataContainerRef".cstr.ptr, - "size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method size" } - }} + val size: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PackedDataContainerRef".cstr.ptr, + "size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method size" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PackedScene.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PackedScene.kt index 41ef3b57..39d4ee04 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PackedScene.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PackedScene.kt @@ -124,33 +124,41 @@ open class PackedScene( * Container for method_bind pointers for PackedScene */ private object __method_bind { - val canInstance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PackedScene".cstr.ptr, - "can_instance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method can_instance" } - } - val getState: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PackedScene".cstr.ptr, - "get_state".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_state" } - } - val instance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PackedScene".cstr.ptr, - "instance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instance" } - } - val pack: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PackedScene".cstr.ptr, - "pack".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method pack" } - }} + val canInstance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PackedScene".cstr.ptr, + "can_instance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method can_instance" } + } + } + + val getState: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PackedScene".cstr.ptr, + "get_state".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_state" } + } + } + + val instance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PackedScene".cstr.ptr, + "instance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method instance" } + } + } + + val pack: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PackedScene".cstr.ptr, + "pack".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method pack" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PacketPeer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PacketPeer.kt index 6b9e9f9c..17b9916b 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PacketPeer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PacketPeer.kt @@ -160,65 +160,95 @@ open class PacketPeer( * Container for method_bind pointers for PacketPeer */ private object __method_bind { - val getAvailablePacketCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, - "get_available_packet_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_available_packet_count" } - } - val getEncodeBufferMaxSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, - "get_encode_buffer_max_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_encode_buffer_max_size" } - } - val getPacket: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, - "get_packet".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_packet" } - } - val getPacketError: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, - "get_packet_error".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_packet_error" } - } - val getVar: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, - "get_var".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_var" } - } - val isObjectDecodingAllowed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, - "is_object_decoding_allowed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_object_decoding_allowed" } - } - val putPacket: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, - "put_packet".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method put_packet" } - } - val putVar: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, - "put_var".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method put_var" } - } - val setAllowObjectDecoding: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, - "set_allow_object_decoding".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_allow_object_decoding" } - } - val setEncodeBufferMaxSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, - "set_encode_buffer_max_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_encode_buffer_max_size" } - }} + val getAvailablePacketCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, + "get_available_packet_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_available_packet_count" } + } + } + + val getEncodeBufferMaxSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, + "get_encode_buffer_max_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_encode_buffer_max_size" } + } + } + + val getPacket: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, + "get_packet".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_packet" } + } + } + + val getPacketError: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, + "get_packet_error".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_packet_error" } + } + } + + val getVar: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, + "get_var".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_var" } + } + } + + val isObjectDecodingAllowed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, + "is_object_decoding_allowed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_object_decoding_allowed" } + } + } + + val putPacket: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, + "put_packet".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method put_packet" } + } + } + + val putVar: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, + "put_var".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method put_var" } + } + } + + val setAllowObjectDecoding: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, + "set_allow_object_decoding".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_allow_object_decoding" } + } + } + + val setEncodeBufferMaxSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeer".cstr.ptr, + "set_encode_buffer_max_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_encode_buffer_max_size" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PacketPeerStream.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PacketPeerStream.kt index d9adf5e3..7517c4dd 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PacketPeerStream.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PacketPeerStream.kt @@ -126,47 +126,59 @@ open class PacketPeerStream( * Container for method_bind pointers for PacketPeerStream */ private object __method_bind { - val getInputBufferMaxSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerStream".cstr.ptr, - "get_input_buffer_max_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_input_buffer_max_size" } - } - val getOutputBufferMaxSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerStream".cstr.ptr, - "get_output_buffer_max_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_output_buffer_max_size" } - } - val getStreamPeer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerStream".cstr.ptr, - "get_stream_peer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stream_peer" } - } - val setInputBufferMaxSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerStream".cstr.ptr, - "set_input_buffer_max_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_input_buffer_max_size" } - } - val setOutputBufferMaxSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerStream".cstr.ptr, - "set_output_buffer_max_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_output_buffer_max_size" } - } - val setStreamPeer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerStream".cstr.ptr, - "set_stream_peer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_stream_peer" } - }} + val getInputBufferMaxSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerStream".cstr.ptr, + "get_input_buffer_max_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_input_buffer_max_size" } + } + } + + val getOutputBufferMaxSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerStream".cstr.ptr, + "get_output_buffer_max_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_output_buffer_max_size" } + } + } + + val getStreamPeer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerStream".cstr.ptr, + "get_stream_peer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stream_peer" } + } + } + + val setInputBufferMaxSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerStream".cstr.ptr, + "set_input_buffer_max_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_input_buffer_max_size" } + } + } + + val setOutputBufferMaxSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerStream".cstr.ptr, + "set_output_buffer_max_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_output_buffer_max_size" } + } + } + + val setStreamPeer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerStream".cstr.ptr, + "set_stream_peer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_stream_peer" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PacketPeerUDP.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PacketPeerUDP.kt index 3b18de27..ee83ae8b 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PacketPeerUDP.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PacketPeerUDP.kt @@ -162,75 +162,95 @@ open class PacketPeerUDP( * Container for method_bind pointers for PacketPeerUDP */ private object __method_bind { - val close: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, - "close".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method close" } - } - val getPacketIp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, - "get_packet_ip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_packet_ip" } - } - val getPacketPort: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, - "get_packet_port".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_packet_port" } - } - val isListening: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, - "is_listening".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_listening" } - } - val joinMulticastGroup: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, - "join_multicast_group".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method join_multicast_group" } - } - val leaveMulticastGroup: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, - "leave_multicast_group".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method leave_multicast_group" } - } - val listen: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, - "listen".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method listen" } - } - val setBroadcastEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, - "set_broadcast_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_broadcast_enabled" } - } - val setDestAddress: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, - "set_dest_address".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_dest_address" } - } - val wait: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, - "wait".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method wait" } - }} + val close: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, + "close".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method close" } + } + } + + val getPacketIp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, + "get_packet_ip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_packet_ip" } + } + } + + val getPacketPort: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, + "get_packet_port".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_packet_port" } + } + } + + val isListening: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, + "is_listening".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_listening" } + } + } + + val joinMulticastGroup: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, + "join_multicast_group".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method join_multicast_group" } + } + } + + val leaveMulticastGroup: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, + "leave_multicast_group".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method leave_multicast_group" } + } + } + + val listen: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, + "listen".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method listen" } + } + } + + val setBroadcastEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, + "set_broadcast_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_broadcast_enabled" } + } + } + + val setDestAddress: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, + "set_dest_address".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_dest_address" } + } + } + + val wait: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PacketPeerUDP".cstr.ptr, + "wait".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method wait" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PanoramaSky.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PanoramaSky.kt index 58f87bee..9f68aef5 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PanoramaSky.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PanoramaSky.kt @@ -74,19 +74,23 @@ open class PanoramaSky( * Container for method_bind pointers for PanoramaSky */ private object __method_bind { - val getPanorama: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PanoramaSky".cstr.ptr, - "get_panorama".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_panorama" } - } - val setPanorama: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PanoramaSky".cstr.ptr, - "set_panorama".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_panorama" } - }} + val getPanorama: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PanoramaSky".cstr.ptr, + "get_panorama".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_panorama" } + } + } + + val setPanorama: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PanoramaSky".cstr.ptr, + "set_panorama".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_panorama" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ParallaxBackground.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ParallaxBackground.kt index d8a4a419..83c862b2 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ParallaxBackground.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ParallaxBackground.kt @@ -256,89 +256,113 @@ open class ParallaxBackground( * Container for method_bind pointers for ParallaxBackground */ private object __method_bind { - val getLimitBegin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, - "get_limit_begin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_limit_begin" } - } - val getLimitEnd: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, - "get_limit_end".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_limit_end" } - } - val getScrollBaseOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, - "get_scroll_base_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_scroll_base_offset" } - } - val getScrollBaseScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, - "get_scroll_base_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_scroll_base_scale" } - } - val getScrollOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, - "get_scroll_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_scroll_offset" } - } - val isIgnoreCameraZoom: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, - "is_ignore_camera_zoom".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_ignore_camera_zoom" } - } - val setIgnoreCameraZoom: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, - "set_ignore_camera_zoom".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ignore_camera_zoom" } - } - val setLimitBegin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, - "set_limit_begin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_limit_begin" } - } - val setLimitEnd: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, - "set_limit_end".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_limit_end" } - } - val setScrollBaseOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, - "set_scroll_base_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_scroll_base_offset" } - } - val setScrollBaseScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, - "set_scroll_base_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_scroll_base_scale" } - } - val setScrollOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, - "set_scroll_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_scroll_offset" } - }} + val getLimitBegin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, + "get_limit_begin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_limit_begin" } + } + } + + val getLimitEnd: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, + "get_limit_end".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_limit_end" } + } + } + + val getScrollBaseOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, + "get_scroll_base_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_scroll_base_offset" } + } + } + + val getScrollBaseScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, + "get_scroll_base_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_scroll_base_scale" } + } + } + + val getScrollOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, + "get_scroll_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_scroll_offset" } + } + } + + val isIgnoreCameraZoom: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, + "is_ignore_camera_zoom".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_ignore_camera_zoom" } + } + } + + val setIgnoreCameraZoom: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, + "set_ignore_camera_zoom".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ignore_camera_zoom" } + } + } + + val setLimitBegin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, + "set_limit_begin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_limit_begin" } + } + } + + val setLimitEnd: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, + "set_limit_end".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_limit_end" } + } + } + + val setScrollBaseOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, + "set_scroll_base_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_scroll_base_offset" } + } + } + + val setScrollBaseScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, + "set_scroll_base_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_scroll_base_scale" } + } + } + + val setScrollOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxBackground".cstr.ptr, + "set_scroll_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_scroll_offset" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ParallaxLayer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ParallaxLayer.kt index 6a551eea..3b6098bd 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ParallaxLayer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ParallaxLayer.kt @@ -154,47 +154,59 @@ open class ParallaxLayer( * Container for method_bind pointers for ParallaxLayer */ private object __method_bind { - val getMirroring: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxLayer".cstr.ptr, - "get_mirroring".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mirroring" } - } - val getMotionOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxLayer".cstr.ptr, - "get_motion_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_motion_offset" } - } - val getMotionScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxLayer".cstr.ptr, - "get_motion_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_motion_scale" } - } - val setMirroring: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxLayer".cstr.ptr, - "set_mirroring".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mirroring" } - } - val setMotionOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxLayer".cstr.ptr, - "set_motion_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_motion_offset" } - } - val setMotionScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxLayer".cstr.ptr, - "set_motion_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_motion_scale" } - }} + val getMirroring: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxLayer".cstr.ptr, + "get_mirroring".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mirroring" } + } + } + + val getMotionOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxLayer".cstr.ptr, + "get_motion_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_motion_offset" } + } + } + + val getMotionScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxLayer".cstr.ptr, + "get_motion_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_motion_scale" } + } + } + + val setMirroring: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxLayer".cstr.ptr, + "set_mirroring".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mirroring" } + } + } + + val setMotionOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxLayer".cstr.ptr, + "set_motion_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_motion_offset" } + } + } + + val setMotionScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParallaxLayer".cstr.ptr, + "set_motion_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_motion_scale" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Particles.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Particles.kt index 25c1716b..e1fe51f3 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Particles.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Particles.kt @@ -534,209 +534,311 @@ open class Particles( * Container for method_bind pointers for Particles */ private object __method_bind { - val captureAabb: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "capture_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method capture_aabb" } - } - val getAmount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "get_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_amount" } - } - val getDrawOrder: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "get_draw_order".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_draw_order" } - } - val getDrawPassMesh: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "get_draw_pass_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_draw_pass_mesh" } - } - val getDrawPasses: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "get_draw_passes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_draw_passes" } - } - val getExplosivenessRatio: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "get_explosiveness_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_explosiveness_ratio" } - } - val getFixedFps: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "get_fixed_fps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fixed_fps" } - } - val getFractionalDelta: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "get_fractional_delta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fractional_delta" } - } - val getLifetime: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "get_lifetime".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_lifetime" } - } - val getOneShot: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "get_one_shot".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_one_shot" } - } - val getPreProcessTime: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "get_pre_process_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pre_process_time" } - } - val getProcessMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "get_process_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_process_material" } - } - val getRandomnessRatio: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "get_randomness_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_randomness_ratio" } - } - val getSpeedScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "get_speed_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_speed_scale" } - } - val getUseLocalCoordinates: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "get_use_local_coordinates".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_use_local_coordinates" } - } - val getVisibilityAabb: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "get_visibility_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_visibility_aabb" } - } - val isEmitting: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "is_emitting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_emitting" } - } - val restart: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "restart".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method restart" } - } - val setAmount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "set_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_amount" } - } - val setDrawOrder: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "set_draw_order".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_draw_order" } - } - val setDrawPassMesh: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "set_draw_pass_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_draw_pass_mesh" } - } - val setDrawPasses: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "set_draw_passes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_draw_passes" } - } - val setEmitting: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "set_emitting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emitting" } - } - val setExplosivenessRatio: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "set_explosiveness_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_explosiveness_ratio" } - } - val setFixedFps: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "set_fixed_fps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fixed_fps" } - } - val setFractionalDelta: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "set_fractional_delta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fractional_delta" } - } - val setLifetime: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "set_lifetime".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_lifetime" } - } - val setOneShot: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "set_one_shot".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_one_shot" } - } - val setPreProcessTime: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "set_pre_process_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pre_process_time" } - } - val setProcessMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "set_process_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_process_material" } - } - val setRandomnessRatio: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "set_randomness_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_randomness_ratio" } - } - val setSpeedScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "set_speed_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_speed_scale" } - } - val setUseLocalCoordinates: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "set_use_local_coordinates".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_local_coordinates" } - } - val setVisibilityAabb: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, - "set_visibility_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_visibility_aabb" } - }} + val captureAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "capture_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method capture_aabb" } + } + } + + val getAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "get_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_amount" } + } + } + + val getDrawOrder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "get_draw_order".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_draw_order" } + } + } + + val getDrawPassMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "get_draw_pass_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_draw_pass_mesh" } + } + } + + val getDrawPasses: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "get_draw_passes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_draw_passes" } + } + } + + val getExplosivenessRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "get_explosiveness_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_explosiveness_ratio" } + } + } + + val getFixedFps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "get_fixed_fps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fixed_fps" } + } + } + + val getFractionalDelta: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "get_fractional_delta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fractional_delta" } + } + } + + val getLifetime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "get_lifetime".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_lifetime" } + } + } + + val getOneShot: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "get_one_shot".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_one_shot" } + } + } + + val getPreProcessTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "get_pre_process_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pre_process_time" } + } + } + + val getProcessMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "get_process_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_process_material" } + } + } + + val getRandomnessRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "get_randomness_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_randomness_ratio" } + } + } + + val getSpeedScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "get_speed_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_speed_scale" } + } + } + + val getUseLocalCoordinates: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "get_use_local_coordinates".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_use_local_coordinates" } + } + } + + val getVisibilityAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "get_visibility_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_visibility_aabb" } + } + } + + val isEmitting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "is_emitting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_emitting" } + } + } + + val restart: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "restart".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method restart" } + } + } + + val setAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "set_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_amount" } + } + } + + val setDrawOrder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "set_draw_order".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_draw_order" } + } + } + + val setDrawPassMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "set_draw_pass_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_draw_pass_mesh" } + } + } + + val setDrawPasses: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "set_draw_passes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_draw_passes" } + } + } + + val setEmitting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "set_emitting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emitting" } + } + } + + val setExplosivenessRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "set_explosiveness_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_explosiveness_ratio" } + } + } + + val setFixedFps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "set_fixed_fps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fixed_fps" } + } + } + + val setFractionalDelta: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "set_fractional_delta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fractional_delta" } + } + } + + val setLifetime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "set_lifetime".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_lifetime" } + } + } + + val setOneShot: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "set_one_shot".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_one_shot" } + } + } + + val setPreProcessTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "set_pre_process_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pre_process_time" } + } + } + + val setProcessMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "set_process_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_process_material" } + } + } + + val setRandomnessRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "set_randomness_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_randomness_ratio" } + } + } + + val setSpeedScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "set_speed_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_speed_scale" } + } + } + + val setUseLocalCoordinates: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "set_use_local_coordinates".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_local_coordinates" } + } + } + + val setVisibilityAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles".cstr.ptr, + "set_visibility_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_visibility_aabb" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Particles2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Particles2D.kt index b3462a00..d660cc4a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Particles2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Particles2D.kt @@ -505,243 +505,311 @@ open class Particles2D( * Container for method_bind pointers for Particles2D */ private object __method_bind { - val captureRect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "capture_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method capture_rect" } - } - val getAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "get_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_amount" } - } - val getDrawOrder: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "get_draw_order".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_draw_order" } - } - val getExplosivenessRatio: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "get_explosiveness_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_explosiveness_ratio" } - } - val getFixedFps: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "get_fixed_fps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fixed_fps" } - } - val getFractionalDelta: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "get_fractional_delta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fractional_delta" } - } - val getLifetime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "get_lifetime".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_lifetime" } - } - val getNormalMap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "get_normal_map".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_normal_map" } - } - val getOneShot: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "get_one_shot".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_one_shot" } - } - val getPreProcessTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "get_pre_process_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pre_process_time" } - } - val getProcessMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "get_process_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_process_material" } - } - val getRandomnessRatio: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "get_randomness_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_randomness_ratio" } - } - val getSpeedScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "get_speed_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_speed_scale" } - } - val getTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "get_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture" } - } - val getUseLocalCoordinates: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "get_use_local_coordinates".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_use_local_coordinates" } - } - val getVisibilityRect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "get_visibility_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_visibility_rect" } - } - val isEmitting: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "is_emitting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_emitting" } - } - val restart: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "restart".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method restart" } - } - val setAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "set_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_amount" } - } - val setDrawOrder: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "set_draw_order".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_draw_order" } - } - val setEmitting: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "set_emitting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emitting" } - } - val setExplosivenessRatio: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "set_explosiveness_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_explosiveness_ratio" } - } - val setFixedFps: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "set_fixed_fps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fixed_fps" } - } - val setFractionalDelta: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "set_fractional_delta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fractional_delta" } - } - val setLifetime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "set_lifetime".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_lifetime" } - } - val setNormalMap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "set_normal_map".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_normal_map" } - } - val setOneShot: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "set_one_shot".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_one_shot" } - } - val setPreProcessTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "set_pre_process_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pre_process_time" } - } - val setProcessMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "set_process_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_process_material" } - } - val setRandomnessRatio: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "set_randomness_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_randomness_ratio" } - } - val setSpeedScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "set_speed_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_speed_scale" } - } - val setTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "set_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture" } - } - val setUseLocalCoordinates: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "set_use_local_coordinates".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_local_coordinates" } - } - val setVisibilityRect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, - "set_visibility_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_visibility_rect" } - }} + val captureRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "capture_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method capture_rect" } + } + } + + val getAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "get_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_amount" } + } + } + + val getDrawOrder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "get_draw_order".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_draw_order" } + } + } + + val getExplosivenessRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "get_explosiveness_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_explosiveness_ratio" } + } + } + + val getFixedFps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "get_fixed_fps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fixed_fps" } + } + } + + val getFractionalDelta: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "get_fractional_delta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fractional_delta" } + } + } + + val getLifetime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "get_lifetime".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_lifetime" } + } + } + + val getNormalMap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "get_normal_map".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_normal_map" } + } + } + + val getOneShot: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "get_one_shot".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_one_shot" } + } + } + + val getPreProcessTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "get_pre_process_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pre_process_time" } + } + } + + val getProcessMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "get_process_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_process_material" } + } + } + + val getRandomnessRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "get_randomness_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_randomness_ratio" } + } + } + + val getSpeedScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "get_speed_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_speed_scale" } + } + } + + val getTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "get_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture" } + } + } + + val getUseLocalCoordinates: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "get_use_local_coordinates".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_use_local_coordinates" } + } + } + + val getVisibilityRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "get_visibility_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_visibility_rect" } + } + } + + val isEmitting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "is_emitting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_emitting" } + } + } + + val restart: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "restart".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method restart" } + } + } + + val setAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "set_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_amount" } + } + } + + val setDrawOrder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "set_draw_order".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_draw_order" } + } + } + + val setEmitting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "set_emitting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emitting" } + } + } + + val setExplosivenessRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "set_explosiveness_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_explosiveness_ratio" } + } + } + + val setFixedFps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "set_fixed_fps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fixed_fps" } + } + } + + val setFractionalDelta: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "set_fractional_delta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fractional_delta" } + } + } + + val setLifetime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "set_lifetime".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_lifetime" } + } + } + + val setNormalMap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "set_normal_map".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_normal_map" } + } + } + + val setOneShot: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "set_one_shot".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_one_shot" } + } + } + + val setPreProcessTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "set_pre_process_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pre_process_time" } + } + } + + val setProcessMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "set_process_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_process_material" } + } + } + + val setRandomnessRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "set_randomness_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_randomness_ratio" } + } + } + + val setSpeedScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "set_speed_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_speed_scale" } + } + } + + val setTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "set_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture" } + } + } + + val setUseLocalCoordinates: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "set_use_local_coordinates".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_local_coordinates" } + } + } + + val setVisibilityRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Particles2D".cstr.ptr, + "set_visibility_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_visibility_rect" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ParticlesMaterial.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ParticlesMaterial.kt index b8a64ed4..6004fe27 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ParticlesMaterial.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ParticlesMaterial.kt @@ -1008,299 +1008,383 @@ open class ParticlesMaterial( * Container for method_bind pointers for ParticlesMaterial */ private object __method_bind { - val getColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_color" } - } - val getColorRamp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_color_ramp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_color_ramp" } - } - val getDirection: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_direction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_direction" } - } - val getEmissionBoxExtents: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_emission_box_extents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_box_extents" } - } - val getEmissionColorTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_emission_color_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_color_texture" } - } - val getEmissionNormalTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_emission_normal_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_normal_texture" } - } - val getEmissionPointCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_emission_point_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_point_count" } - } - val getEmissionPointTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_emission_point_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_point_texture" } - } - val getEmissionShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_emission_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_shape" } - } - val getEmissionSphereRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_emission_sphere_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_sphere_radius" } - } - val getFlag: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_flag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_flag" } - } - val getFlatness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_flatness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_flatness" } - } - val getGravity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_gravity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gravity" } - } - val getLifetimeRandomness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_lifetime_randomness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_lifetime_randomness" } - } - val getParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_param" } - } - val getParamRandomness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_param_randomness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_param_randomness" } - } - val getParamTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_param_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_param_texture" } - } - val getSpread: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_spread".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_spread" } - } - val getTrailColorModifier: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_trail_color_modifier".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_trail_color_modifier" } - } - val getTrailDivisor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_trail_divisor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_trail_divisor" } - } - val getTrailSizeModifier: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "get_trail_size_modifier".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_trail_size_modifier" } - } - val setColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_color" } - } - val setColorRamp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_color_ramp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_color_ramp" } - } - val setDirection: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_direction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_direction" } - } - val setEmissionBoxExtents: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_emission_box_extents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_box_extents" } - } - val setEmissionColorTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_emission_color_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_color_texture" } - } - val setEmissionNormalTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_emission_normal_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_normal_texture" } - } - val setEmissionPointCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_emission_point_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_point_count" } - } - val setEmissionPointTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_emission_point_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_point_texture" } - } - val setEmissionShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_emission_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_shape" } - } - val setEmissionSphereRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_emission_sphere_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_sphere_radius" } - } - val setFlag: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_flag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flag" } - } - val setFlatness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_flatness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flatness" } - } - val setGravity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_gravity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_gravity" } - } - val setLifetimeRandomness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_lifetime_randomness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_lifetime_randomness" } - } - val setParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_param" } - } - val setParamRandomness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_param_randomness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_param_randomness" } - } - val setParamTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_param_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_param_texture" } - } - val setSpread: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_spread".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_spread" } - } - val setTrailColorModifier: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_trail_color_modifier".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_trail_color_modifier" } - } - val setTrailDivisor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_trail_divisor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_trail_divisor" } - } - val setTrailSizeModifier: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, - "set_trail_size_modifier".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_trail_size_modifier" } - }} + val getColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_color" } + } + } + + val getColorRamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_color_ramp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_color_ramp" } + } + } + + val getDirection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_direction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_direction" } + } + } + + val getEmissionBoxExtents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_emission_box_extents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_box_extents" } + } + } + + val getEmissionColorTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_emission_color_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_color_texture" } + } + } + + val getEmissionNormalTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_emission_normal_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_normal_texture" } + } + } + + val getEmissionPointCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_emission_point_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_point_count" } + } + } + + val getEmissionPointTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_emission_point_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_point_texture" } + } + } + + val getEmissionShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_emission_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_shape" } + } + } + + val getEmissionSphereRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_emission_sphere_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_sphere_radius" } + } + } + + val getFlag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_flag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_flag" } + } + } + + val getFlatness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_flatness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_flatness" } + } + } + + val getGravity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_gravity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gravity" } + } + } + + val getLifetimeRandomness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_lifetime_randomness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_lifetime_randomness" } + } + } + + val getParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_param" } + } + } + + val getParamRandomness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_param_randomness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_param_randomness" } + } + } + + val getParamTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_param_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_param_texture" } + } + } + + val getSpread: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_spread".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_spread" } + } + } + + val getTrailColorModifier: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_trail_color_modifier".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_trail_color_modifier" } + } + } + + val getTrailDivisor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_trail_divisor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_trail_divisor" } + } + } + + val getTrailSizeModifier: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "get_trail_size_modifier".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_trail_size_modifier" } + } + } + + val setColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_color" } + } + } + + val setColorRamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_color_ramp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_color_ramp" } + } + } + + val setDirection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_direction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_direction" } + } + } + + val setEmissionBoxExtents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_emission_box_extents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_box_extents" } + } + } + + val setEmissionColorTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_emission_color_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_color_texture" } + } + } + + val setEmissionNormalTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_emission_normal_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_normal_texture" } + } + } + + val setEmissionPointCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_emission_point_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_point_count" } + } + } + + val setEmissionPointTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_emission_point_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_point_texture" } + } + } + + val setEmissionShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_emission_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_shape" } + } + } + + val setEmissionSphereRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_emission_sphere_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_sphere_radius" } + } + } + + val setFlag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_flag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flag" } + } + } + + val setFlatness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_flatness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flatness" } + } + } + + val setGravity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_gravity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_gravity" } + } + } + + val setLifetimeRandomness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_lifetime_randomness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_lifetime_randomness" } + } + } + + val setParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_param" } + } + } + + val setParamRandomness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_param_randomness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_param_randomness" } + } + } + + val setParamTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_param_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_param_texture" } + } + } + + val setSpread: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_spread".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_spread" } + } + } + + val setTrailColorModifier: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_trail_color_modifier".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_trail_color_modifier" } + } + } + + val setTrailDivisor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_trail_divisor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_trail_divisor" } + } + } + + val setTrailSizeModifier: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ParticlesMaterial".cstr.ptr, + "set_trail_size_modifier".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_trail_size_modifier" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Path.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Path.kt index c455217e..6858afd2 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Path.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Path.kt @@ -83,17 +83,21 @@ open class Path( * Container for method_bind pointers for Path */ private object __method_bind { - val getCurve: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Path".cstr.ptr, - "get_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_curve" } - } - val setCurve: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Path".cstr.ptr, - "set_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_curve" } - }} + val getCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Path".cstr.ptr, + "get_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_curve" } + } + } + + val setCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Path".cstr.ptr, + "set_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_curve" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Path2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Path2D.kt index f14f3786..ab495d0d 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Path2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Path2D.kt @@ -78,17 +78,21 @@ open class Path2D( * Container for method_bind pointers for Path2D */ private object __method_bind { - val getCurve: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Path2D".cstr.ptr, - "get_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_curve" } - } - val setCurve: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Path2D".cstr.ptr, - "set_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_curve" } - }} + val getCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Path2D".cstr.ptr, + "get_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_curve" } + } + } + + val setCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Path2D".cstr.ptr, + "set_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_curve" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PathFollow.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PathFollow.kt index e151940e..ccf424f5 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PathFollow.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PathFollow.kt @@ -250,89 +250,131 @@ open class PathFollow( * Container for method_bind pointers for PathFollow */ private object __method_bind { - val getCubicInterpolation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, - "get_cubic_interpolation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cubic_interpolation" } - } - val getHOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, - "get_h_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_h_offset" } - } - val getOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, - "get_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_offset" } - } - val getRotationMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, - "get_rotation_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rotation_mode" } - } - val getUnitOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, - "get_unit_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_unit_offset" } - } - val getVOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, - "get_v_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_v_offset" } - } - val hasLoop: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, - "has_loop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_loop" } - } - val setCubicInterpolation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, - "set_cubic_interpolation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cubic_interpolation" } - } - val setHOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, - "set_h_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_h_offset" } - } - val setLoop: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, - "set_loop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_loop" } - } - val setOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, - "set_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_offset" } - } - val setRotationMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, - "set_rotation_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rotation_mode" } - } - val setUnitOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, - "set_unit_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_unit_offset" } - } - val setVOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, - "set_v_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_v_offset" } - }} + val getCubicInterpolation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, + "get_cubic_interpolation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cubic_interpolation" } + } + } + + val getHOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, + "get_h_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_h_offset" } + } + } + + val getOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, + "get_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_offset" } + } + } + + val getRotationMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, + "get_rotation_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rotation_mode" } + } + } + + val getUnitOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, + "get_unit_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_unit_offset" } + } + } + + val getVOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, + "get_v_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_v_offset" } + } + } + + val hasLoop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, + "has_loop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_loop" } + } + } + + val setCubicInterpolation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, + "set_cubic_interpolation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cubic_interpolation" } + } + } + + val setHOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, + "set_h_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_h_offset" } + } + } + + val setLoop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, + "set_loop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_loop" } + } + } + + val setOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, + "set_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_offset" } + } + } + + val setRotationMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, + "set_rotation_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rotation_mode" } + } + } + + val setUnitOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, + "set_unit_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_unit_offset" } + } + } + + val setVOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow".cstr.ptr, + "set_v_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_v_offset" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PathFollow2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PathFollow2D.kt index 9fa95a16..531d82b9 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PathFollow2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PathFollow2D.kt @@ -249,117 +249,149 @@ open class PathFollow2D( * Container for method_bind pointers for PathFollow2D */ private object __method_bind { - val getCubicInterpolation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, - "get_cubic_interpolation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cubic_interpolation" } - } - val getHOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, - "get_h_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_h_offset" } - } - val getLookahead: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, - "get_lookahead".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_lookahead" } - } - val getOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, - "get_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_offset" } - } - val getUnitOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, - "get_unit_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_unit_offset" } - } - val getVOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, - "get_v_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_v_offset" } - } - val hasLoop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, - "has_loop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_loop" } - } - val isRotating: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, - "is_rotating".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_rotating" } - } - val setCubicInterpolation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, - "set_cubic_interpolation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cubic_interpolation" } - } - val setHOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, - "set_h_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_h_offset" } - } - val setLookahead: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, - "set_lookahead".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_lookahead" } - } - val setLoop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, - "set_loop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_loop" } - } - val setOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, - "set_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_offset" } - } - val setRotate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, - "set_rotate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rotate" } - } - val setUnitOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, - "set_unit_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_unit_offset" } - } - val setVOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, - "set_v_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_v_offset" } - }} + val getCubicInterpolation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, + "get_cubic_interpolation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cubic_interpolation" } + } + } + + val getHOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, + "get_h_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_h_offset" } + } + } + + val getLookahead: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, + "get_lookahead".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_lookahead" } + } + } + + val getOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, + "get_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_offset" } + } + } + + val getUnitOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, + "get_unit_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_unit_offset" } + } + } + + val getVOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, + "get_v_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_v_offset" } + } + } + + val hasLoop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, + "has_loop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_loop" } + } + } + + val isRotating: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, + "is_rotating".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_rotating" } + } + } + + val setCubicInterpolation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, + "set_cubic_interpolation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cubic_interpolation" } + } + } + + val setHOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, + "set_h_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_h_offset" } + } + } + + val setLookahead: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, + "set_lookahead".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_lookahead" } + } + } + + val setLoop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, + "set_loop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_loop" } + } + } + + val setOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, + "set_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_offset" } + } + } + + val setRotate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, + "set_rotate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rotate" } + } + } + + val setUnitOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, + "set_unit_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_unit_offset" } + } + } + + val setVOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PathFollow2D".cstr.ptr, + "set_v_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_v_offset" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Performance.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Performance.kt index 6509d0cf..44754e52 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Performance.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Performance.kt @@ -47,13 +47,15 @@ open class PerformanceInternal( * Container for method_bind pointers for Performance */ private object __method_bind { - val getMonitor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Performance".cstr.ptr, - "get_monitor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_monitor" } - }} + val getMonitor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Performance".cstr.ptr, + "get_monitor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_monitor" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PhysicalBone.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PhysicalBone.kt index 95d45adc..b6835e81 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PhysicalBone.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PhysicalBone.kt @@ -361,159 +361,203 @@ open class PhysicalBone( * Container for method_bind pointers for PhysicalBone */ private object __method_bind { - val applyCentralImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "apply_central_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method apply_central_impulse" } - } - val applyImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "apply_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method apply_impulse" } - } - val getBodyOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "get_body_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_body_offset" } - } - val getBoneId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "get_bone_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bone_id" } - } - val getBounce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "get_bounce".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bounce" } - } - val getFriction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "get_friction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_friction" } - } - val getGravityScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "get_gravity_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gravity_scale" } - } - val getJointOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "get_joint_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_joint_offset" } - } - val getJointType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "get_joint_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_joint_type" } - } - val getMass: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "get_mass".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mass" } - } - val getSimulatePhysics: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "get_simulate_physics".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_simulate_physics" } - } - val getWeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "get_weight".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_weight" } - } - val isSimulatingPhysics: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "is_simulating_physics".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_simulating_physics" } - } - val isStaticBody: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "is_static_body".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_static_body" } - } - val setBodyOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "set_body_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_body_offset" } - } - val setBounce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "set_bounce".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bounce" } - } - val setFriction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "set_friction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_friction" } - } - val setGravityScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "set_gravity_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_gravity_scale" } - } - val setJointOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "set_joint_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_joint_offset" } - } - val setJointType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "set_joint_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_joint_type" } - } - val setMass: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "set_mass".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mass" } - } - val setWeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, - "set_weight".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_weight" } - }} + val applyCentralImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "apply_central_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method apply_central_impulse" } + } + } + + val applyImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "apply_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method apply_impulse" } + } + } + + val getBodyOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "get_body_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_body_offset" } + } + } + + val getBoneId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "get_bone_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bone_id" } + } + } + + val getBounce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "get_bounce".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bounce" } + } + } + + val getFriction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "get_friction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_friction" } + } + } + + val getGravityScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "get_gravity_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gravity_scale" } + } + } + + val getJointOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "get_joint_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_joint_offset" } + } + } + + val getJointType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "get_joint_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_joint_type" } + } + } + + val getMass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "get_mass".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mass" } + } + } + + val getSimulatePhysics: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "get_simulate_physics".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_simulate_physics" } + } + } + + val getWeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "get_weight".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_weight" } + } + } + + val isSimulatingPhysics: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "is_simulating_physics".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_simulating_physics" } + } + } + + val isStaticBody: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "is_static_body".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_static_body" } + } + } + + val setBodyOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "set_body_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_body_offset" } + } + } + + val setBounce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "set_bounce".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bounce" } + } + } + + val setFriction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "set_friction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_friction" } + } + } + + val setGravityScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "set_gravity_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_gravity_scale" } + } + } + + val setJointOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "set_joint_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_joint_offset" } + } + } + + val setJointType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "set_joint_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_joint_type" } + } + } + + val setMass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "set_mass".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mass" } + } + } + + val setWeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicalBone".cstr.ptr, + "set_weight".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_weight" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DDirectBodyState.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DDirectBodyState.kt index abc20fd2..a0a09e3d 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DDirectBodyState.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DDirectBodyState.kt @@ -445,238 +445,305 @@ open class Physics2DDirectBodyState( * Container for method_bind pointers for Physics2DDirectBodyState */ private object __method_bind { - val addCentralForce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "add_central_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_central_force" } - } - val addForce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "add_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_force" } - } - val addTorque: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "add_torque".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_torque" } - } - val applyCentralImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "apply_central_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method apply_central_impulse" } - } - val applyImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "apply_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method apply_impulse" } - } - val applyTorqueImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "apply_torque_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method apply_torque_impulse" } - } - val getAngularVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_angular_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_angular_velocity" } - } - val getContactCollider: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_contact_collider".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_contact_collider" } - } - val getContactColliderId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_contact_collider_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_contact_collider_id" } - } - val getContactColliderObject: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_contact_collider_object".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_contact_collider_object" } - } - val getContactColliderPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_contact_collider_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_contact_collider_position" } - } - val getContactColliderShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_contact_collider_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_contact_collider_shape" } - } - val getContactColliderShapeMetadata: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_contact_collider_shape_metadata".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method get_contact_collider_shape_metadata" } - } - val getContactColliderVelocityAtPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_contact_collider_velocity_at_position".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method get_contact_collider_velocity_at_position" } - } - val getContactCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_contact_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_contact_count" } - } - val getContactLocalNormal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_contact_local_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_contact_local_normal" } - } - val getContactLocalPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_contact_local_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_contact_local_position" } - } - val getContactLocalShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_contact_local_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_contact_local_shape" } - } - val getInverseInertia: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_inverse_inertia".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_inverse_inertia" } - } - val getInverseMass: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_inverse_mass".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_inverse_mass" } - } - val getLinearVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_linear_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_linear_velocity" } - } - val getSpaceState: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_space_state".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_space_state" } - } - val getStep: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_step".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_step" } - } - val getTotalAngularDamp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_total_angular_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_total_angular_damp" } - } - val getTotalGravity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_total_gravity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_total_gravity" } - } - val getTotalLinearDamp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_total_linear_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_total_linear_damp" } - } - val getTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "get_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_transform" } - } - val integrateForces: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "integrate_forces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method integrate_forces" } - } - val isSleeping: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "is_sleeping".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_sleeping" } - } - val setAngularVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "set_angular_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_angular_velocity" } - } - val setLinearVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "set_linear_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_linear_velocity" } - } - val setSleepState: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "set_sleep_state".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sleep_state" } - } - val setTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, - "set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_transform" } - }} + val addCentralForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "add_central_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_central_force" } + } + } + + val addForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "add_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_force" } + } + } + + val addTorque: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "add_torque".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_torque" } + } + } + + val applyCentralImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "apply_central_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method apply_central_impulse" } + } + } + + val applyImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "apply_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method apply_impulse" } + } + } + + val applyTorqueImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "apply_torque_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method apply_torque_impulse" } + } + } + + val getAngularVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_angular_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_angular_velocity" } + } + } + + val getContactCollider: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_contact_collider".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_contact_collider" } + } + } + + val getContactColliderId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_contact_collider_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_contact_collider_id" } + } + } + + val getContactColliderObject: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_contact_collider_object".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_contact_collider_object" } + } + } + + val getContactColliderPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_contact_collider_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_contact_collider_position" + } + } + } + + val getContactColliderShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_contact_collider_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_contact_collider_shape" } + } + } + + val getContactColliderShapeMetadata: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_contact_collider_shape_metadata".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_contact_collider_shape_metadata" } + } + } + + val getContactColliderVelocityAtPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_contact_collider_velocity_at_position".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_contact_collider_velocity_at_position" } + } + } + + val getContactCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_contact_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_contact_count" } + } + } + + val getContactLocalNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_contact_local_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_contact_local_normal" } + } + } + + val getContactLocalPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_contact_local_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_contact_local_position" } + } + } + + val getContactLocalShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_contact_local_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_contact_local_shape" } + } + } + + val getInverseInertia: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_inverse_inertia".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_inverse_inertia" } + } + } + + val getInverseMass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_inverse_mass".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_inverse_mass" } + } + } + + val getLinearVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_linear_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_linear_velocity" } + } + } + + val getSpaceState: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_space_state".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_space_state" } + } + } + + val getStep: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_step".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_step" } + } + } + + val getTotalAngularDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_total_angular_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_total_angular_damp" } + } + } + + val getTotalGravity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_total_gravity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_total_gravity" } + } + } + + val getTotalLinearDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_total_linear_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_total_linear_damp" } + } + } + + val getTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "get_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_transform" } + } + } + + val integrateForces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "integrate_forces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method integrate_forces" } + } + } + + val isSleeping: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "is_sleeping".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_sleeping" } + } + } + + val setAngularVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "set_angular_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_angular_velocity" } + } + } + + val setLinearVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "set_linear_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_linear_velocity" } + } + } + + val setSleepState: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "set_sleep_state".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sleep_state" } + } + } + + val setTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectBodyState".cstr.ptr, + "set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_transform" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DDirectSpaceState.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DDirectSpaceState.kt index 6057532f..c8f3a355 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DDirectSpaceState.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DDirectSpaceState.kt @@ -172,54 +172,68 @@ open class Physics2DDirectSpaceState( * Container for method_bind pointers for Physics2DDirectSpaceState */ private object __method_bind { - val castMotion: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectSpaceState".cstr.ptr, - "cast_motion".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cast_motion" } - } - val collideShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectSpaceState".cstr.ptr, - "collide_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method collide_shape" } - } - val getRestInfo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectSpaceState".cstr.ptr, - "get_rest_info".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rest_info" } - } - val intersectPoint: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectSpaceState".cstr.ptr, - "intersect_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method intersect_point" } - } - val intersectPointOnCanvas: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectSpaceState".cstr.ptr, - "intersect_point_on_canvas".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method intersect_point_on_canvas" } - } - val intersectRay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectSpaceState".cstr.ptr, - "intersect_ray".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method intersect_ray" } - } - val intersectShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectSpaceState".cstr.ptr, - "intersect_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method intersect_shape" } - }} + val castMotion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectSpaceState".cstr.ptr, + "cast_motion".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cast_motion" } + } + } + + val collideShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectSpaceState".cstr.ptr, + "collide_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method collide_shape" } + } + } + + val getRestInfo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectSpaceState".cstr.ptr, + "get_rest_info".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rest_info" } + } + } + + val intersectPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectSpaceState".cstr.ptr, + "intersect_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method intersect_point" } + } + } + + val intersectPointOnCanvas: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectSpaceState".cstr.ptr, + "intersect_point_on_canvas".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method intersect_point_on_canvas" } + } + } + + val intersectRay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectSpaceState".cstr.ptr, + "intersect_ray".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method intersect_ray" } + } + } + + val intersectShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DDirectSpaceState".cstr.ptr, + "intersect_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method intersect_shape" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DServer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DServer.kt index 432b5f46..828e5973 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DServer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DServer.kt @@ -1269,725 +1269,940 @@ open class Physics2DServerInternal( * Container for method_bind pointers for Physics2DServer */ private object __method_bind { - val areaAddShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_add_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_add_shape" } - } - val areaAttachCanvasInstanceId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_attach_canvas_instance_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_attach_canvas_instance_id" } - } - val areaAttachObjectInstanceId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_attach_object_instance_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_attach_object_instance_id" } - } - val areaClearShapes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_clear_shapes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_clear_shapes" } - } - val areaCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_create" } - } - val areaGetCanvasInstanceId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_get_canvas_instance_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_get_canvas_instance_id" } - } - val areaGetObjectInstanceId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_get_object_instance_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_get_object_instance_id" } - } - val areaGetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_get_param" } - } - val areaGetShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_get_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_get_shape" } - } - val areaGetShapeCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_get_shape_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_get_shape_count" } - } - val areaGetShapeTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_get_shape_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_get_shape_transform" } - } - val areaGetSpace: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_get_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_get_space" } - } - val areaGetSpaceOverrideMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_get_space_override_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_get_space_override_mode" } - } - val areaGetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_get_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_get_transform" } - } - val areaRemoveShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_remove_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_remove_shape" } - } - val areaSetAreaMonitorCallback: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_set_area_monitor_callback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_area_monitor_callback" } - } - val areaSetCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_set_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_collision_layer" } - } - val areaSetCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_set_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_collision_mask" } - } - val areaSetMonitorCallback: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_set_monitor_callback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_monitor_callback" } - } - val areaSetMonitorable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_set_monitorable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_monitorable" } - } - val areaSetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_param" } - } - val areaSetShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_set_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_shape" } - } - val areaSetShapeDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_set_shape_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_shape_disabled" } - } - val areaSetShapeTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_set_shape_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_shape_transform" } - } - val areaSetSpace: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_set_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_space" } - } - val areaSetSpaceOverrideMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_set_space_override_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_space_override_mode" } - } - val areaSetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "area_set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_transform" } - } - val bodyAddCentralForce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_add_central_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_add_central_force" } - } - val bodyAddCollisionException: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_add_collision_exception".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_add_collision_exception" } - } - val bodyAddForce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_add_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_add_force" } - } - val bodyAddShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_add_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_add_shape" } - } - val bodyAddTorque: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_add_torque".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_add_torque" } - } - val bodyApplyCentralImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_apply_central_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_apply_central_impulse" } - } - val bodyApplyImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_apply_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_apply_impulse" } - } - val bodyApplyTorqueImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_apply_torque_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_apply_torque_impulse" } - } - val bodyAttachCanvasInstanceId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_attach_canvas_instance_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_attach_canvas_instance_id" } - } - val bodyAttachObjectInstanceId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_attach_object_instance_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_attach_object_instance_id" } - } - val bodyClearShapes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_clear_shapes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_clear_shapes" } - } - val bodyCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_create" } - } - val bodyGetCanvasInstanceId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_get_canvas_instance_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_canvas_instance_id" } - } - val bodyGetCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_get_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_collision_layer" } - } - val bodyGetCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_get_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_collision_mask" } - } - val bodyGetContinuousCollisionDetectionMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_get_continuous_collision_detection_mode".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method body_get_continuous_collision_detection_mode" } - } - val bodyGetDirectState: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_get_direct_state".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_direct_state" } - } - val bodyGetMaxContactsReported: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_get_max_contacts_reported".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_max_contacts_reported" } - } - val bodyGetMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_get_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_mode" } - } - val bodyGetObjectInstanceId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_get_object_instance_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_object_instance_id" } - } - val bodyGetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_param" } - } - val bodyGetShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_get_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_shape" } - } - val bodyGetShapeCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_get_shape_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_shape_count" } - } - val bodyGetShapeMetadata: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_get_shape_metadata".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_shape_metadata" } - } - val bodyGetShapeTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_get_shape_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_shape_transform" } - } - val bodyGetSpace: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_get_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_space" } - } - val bodyGetState: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_get_state".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_state" } - } - val bodyIsOmittingForceIntegration: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_is_omitting_force_integration".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_is_omitting_force_integration" + val areaAddShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_add_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_add_shape" } } - } - val bodyRemoveCollisionException: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_remove_collision_exception".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_remove_collision_exception" } - } - val bodyRemoveShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_remove_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_remove_shape" } - } - val bodySetAxisVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_set_axis_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_axis_velocity" } - } - val bodySetCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_set_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_collision_layer" } - } - val bodySetCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_set_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_collision_mask" } - } - val bodySetContinuousCollisionDetectionMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_set_continuous_collision_detection_mode".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method body_set_continuous_collision_detection_mode" } - } - val bodySetForceIntegrationCallback: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_set_force_integration_callback".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method body_set_force_integration_callback" } - } - val bodySetMaxContactsReported: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_set_max_contacts_reported".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_max_contacts_reported" } - } - val bodySetMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_set_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_mode" } - } - val bodySetOmitForceIntegration: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_set_omit_force_integration".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_omit_force_integration" } - } - val bodySetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_param" } - } - val bodySetShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_set_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_shape" } - } - val bodySetShapeAsOneWayCollision: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_set_shape_as_one_way_collision".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method body_set_shape_as_one_way_collision" } - } - val bodySetShapeDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_set_shape_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_shape_disabled" } - } - val bodySetShapeMetadata: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_set_shape_metadata".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_shape_metadata" } - } - val bodySetShapeTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_set_shape_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_shape_transform" } - } - val bodySetSpace: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_set_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_space" } - } - val bodySetState: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_set_state".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_state" } - } - val bodyTestMotion: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "body_test_motion".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_test_motion" } - } - val capsuleShapeCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "capsule_shape_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method capsule_shape_create" } - } - val circleShapeCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "circle_shape_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method circle_shape_create" } - } - val concavePolygonShapeCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "concave_polygon_shape_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method concave_polygon_shape_create" } - } - val convexPolygonShapeCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "convex_polygon_shape_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method convex_polygon_shape_create" } - } - val dampedSpringJointCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "damped_spring_joint_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method damped_spring_joint_create" } - } - val dampedStringJointGetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "damped_string_joint_get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method damped_string_joint_get_param" } - } - val dampedStringJointSetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "damped_string_joint_set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method damped_string_joint_set_param" } - } - val freeRid: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "free_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method free_rid" } - } - val getProcessInfo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "get_process_info".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_process_info" } - } - val grooveJointCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "groove_joint_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method groove_joint_create" } - } - val jointGetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "joint_get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method joint_get_param" } - } - val jointGetType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "joint_get_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method joint_get_type" } - } - val jointSetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "joint_set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method joint_set_param" } - } - val lineShapeCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "line_shape_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method line_shape_create" } - } - val pinJointCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "pin_joint_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method pin_joint_create" } - } - val rayShapeCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "ray_shape_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method ray_shape_create" } - } - val rectangleShapeCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "rectangle_shape_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rectangle_shape_create" } - } - val segmentShapeCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "segment_shape_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method segment_shape_create" } - } - val setActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "set_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_active" } - } - val shapeGetData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "shape_get_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_get_data" } - } - val shapeGetType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "shape_get_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_get_type" } - } - val shapeSetData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "shape_set_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_set_data" } - } - val spaceCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "space_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method space_create" } - } - val spaceGetDirectState: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "space_get_direct_state".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method space_get_direct_state" } - } - val spaceGetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "space_get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method space_get_param" } - } - val spaceIsActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "space_is_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method space_is_active" } - } - val spaceSetActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "space_set_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method space_set_active" } - } - val spaceSetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, - "space_set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method space_set_param" } - }} + } + + val areaAttachCanvasInstanceId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_attach_canvas_instance_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_attach_canvas_instance_id" + } + } + } + + val areaAttachObjectInstanceId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_attach_object_instance_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_attach_object_instance_id" + } + } + } + + val areaClearShapes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_clear_shapes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_clear_shapes" } + } + } + + val areaCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_create" } + } + } + + val areaGetCanvasInstanceId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_get_canvas_instance_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_get_canvas_instance_id" } + } + } + + val areaGetObjectInstanceId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_get_object_instance_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_get_object_instance_id" } + } + } + + val areaGetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_get_param" } + } + } + + val areaGetShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_get_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_get_shape" } + } + } + + val areaGetShapeCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_get_shape_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_get_shape_count" } + } + } + + val areaGetShapeTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_get_shape_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_get_shape_transform" } + } + } + + val areaGetSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_get_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_get_space" } + } + } + + val areaGetSpaceOverrideMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_get_space_override_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_get_space_override_mode" } + } + } + + val areaGetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_get_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_get_transform" } + } + } + + val areaRemoveShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_remove_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_remove_shape" } + } + } + + val areaSetAreaMonitorCallback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_set_area_monitor_callback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_area_monitor_callback" + } + } + } + + val areaSetCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_set_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_collision_layer" } + } + } + + val areaSetCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_set_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_collision_mask" } + } + } + + val areaSetMonitorCallback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_set_monitor_callback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_monitor_callback" } + } + } + + val areaSetMonitorable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_set_monitorable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_monitorable" } + } + } + + val areaSetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_param" } + } + } + + val areaSetShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_set_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_shape" } + } + } + + val areaSetShapeDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_set_shape_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_shape_disabled" } + } + } + + val areaSetShapeTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_set_shape_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_shape_transform" } + } + } + + val areaSetSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_set_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_space" } + } + } + + val areaSetSpaceOverrideMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_set_space_override_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_space_override_mode" } + } + } + + val areaSetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "area_set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_transform" } + } + } + + val bodyAddCentralForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_add_central_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_add_central_force" } + } + } + + val bodyAddCollisionException: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_add_collision_exception".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_add_collision_exception" } + } + } + + val bodyAddForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_add_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_add_force" } + } + } + + val bodyAddShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_add_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_add_shape" } + } + } + + val bodyAddTorque: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_add_torque".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_add_torque" } + } + } + + val bodyApplyCentralImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_apply_central_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_apply_central_impulse" } + } + } + + val bodyApplyImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_apply_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_apply_impulse" } + } + } + + val bodyApplyTorqueImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_apply_torque_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_apply_torque_impulse" } + } + } + + val bodyAttachCanvasInstanceId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_attach_canvas_instance_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_attach_canvas_instance_id" + } + } + } + + val bodyAttachObjectInstanceId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_attach_object_instance_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_attach_object_instance_id" + } + } + } + + val bodyClearShapes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_clear_shapes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_clear_shapes" } + } + } + + val bodyCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_create" } + } + } + + val bodyGetCanvasInstanceId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_get_canvas_instance_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_canvas_instance_id" } + } + } + + val bodyGetCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_get_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_collision_layer" } + } + } + + val bodyGetCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_get_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_collision_mask" } + } + } + + val bodyGetContinuousCollisionDetectionMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_get_continuous_collision_detection_mode".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method body_get_continuous_collision_detection_mode" } + } + } + + val bodyGetDirectState: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_get_direct_state".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_direct_state" } + } + } + + val bodyGetMaxContactsReported: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_get_max_contacts_reported".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_max_contacts_reported" + } + } + } + + val bodyGetMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_get_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_mode" } + } + } + + val bodyGetObjectInstanceId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_get_object_instance_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_object_instance_id" } + } + } + + val bodyGetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_param" } + } + } + + val bodyGetShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_get_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_shape" } + } + } + + val bodyGetShapeCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_get_shape_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_shape_count" } + } + } + + val bodyGetShapeMetadata: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_get_shape_metadata".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_shape_metadata" } + } + } + + val bodyGetShapeTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_get_shape_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_shape_transform" } + } + } + + val bodyGetSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_get_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_space" } + } + } + + val bodyGetState: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_get_state".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_state" } + } + } + + val bodyIsOmittingForceIntegration: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_is_omitting_force_integration".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method body_is_omitting_force_integration" } + } + } + + val bodyRemoveCollisionException: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_remove_collision_exception".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method body_remove_collision_exception" } + } + } + + val bodyRemoveShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_remove_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_remove_shape" } + } + } + + val bodySetAxisVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_set_axis_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_axis_velocity" } + } + } + + val bodySetCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_set_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_collision_layer" } + } + } + + val bodySetCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_set_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_collision_mask" } + } + } + + val bodySetContinuousCollisionDetectionMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_set_continuous_collision_detection_mode".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method body_set_continuous_collision_detection_mode" } + } + } + + val bodySetForceIntegrationCallback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_set_force_integration_callback".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method body_set_force_integration_callback" } + } + } + + val bodySetMaxContactsReported: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_set_max_contacts_reported".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_max_contacts_reported" + } + } + } + + val bodySetMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_set_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_mode" } + } + } + + val bodySetOmitForceIntegration: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_set_omit_force_integration".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method body_set_omit_force_integration" } + } + } + + val bodySetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_param" } + } + } + + val bodySetShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_set_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_shape" } + } + } + + val bodySetShapeAsOneWayCollision: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_set_shape_as_one_way_collision".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method body_set_shape_as_one_way_collision" } + } + } + + val bodySetShapeDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_set_shape_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_shape_disabled" } + } + } + + val bodySetShapeMetadata: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_set_shape_metadata".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_shape_metadata" } + } + } + + val bodySetShapeTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_set_shape_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_shape_transform" } + } + } + + val bodySetSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_set_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_space" } + } + } + + val bodySetState: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_set_state".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_state" } + } + } + + val bodyTestMotion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "body_test_motion".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_test_motion" } + } + } + + val capsuleShapeCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "capsule_shape_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method capsule_shape_create" } + } + } + + val circleShapeCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "circle_shape_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method circle_shape_create" } + } + } + + val concavePolygonShapeCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "concave_polygon_shape_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method concave_polygon_shape_create" } + } + } + + val convexPolygonShapeCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "convex_polygon_shape_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method convex_polygon_shape_create" } + } + } + + val dampedSpringJointCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "damped_spring_joint_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method damped_spring_joint_create" } + } + } + + val dampedStringJointGetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "damped_string_joint_get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method damped_string_joint_get_param" + } + } + } + + val dampedStringJointSetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "damped_string_joint_set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method damped_string_joint_set_param" + } + } + } + + val freeRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "free_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method free_rid" } + } + } + + val getProcessInfo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "get_process_info".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_process_info" } + } + } + + val grooveJointCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "groove_joint_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method groove_joint_create" } + } + } + + val jointGetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "joint_get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method joint_get_param" } + } + } + + val jointGetType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "joint_get_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method joint_get_type" } + } + } + + val jointSetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "joint_set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method joint_set_param" } + } + } + + val lineShapeCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "line_shape_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method line_shape_create" } + } + } + + val pinJointCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "pin_joint_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method pin_joint_create" } + } + } + + val rayShapeCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "ray_shape_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method ray_shape_create" } + } + } + + val rectangleShapeCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "rectangle_shape_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rectangle_shape_create" } + } + } + + val segmentShapeCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "segment_shape_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method segment_shape_create" } + } + } + + val setActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "set_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_active" } + } + } + + val shapeGetData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "shape_get_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_get_data" } + } + } + + val shapeGetType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "shape_get_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_get_type" } + } + } + + val shapeSetData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "shape_set_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_set_data" } + } + } + + val spaceCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "space_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method space_create" } + } + } + + val spaceGetDirectState: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "space_get_direct_state".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method space_get_direct_state" } + } + } + + val spaceGetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "space_get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method space_get_param" } + } + } + + val spaceIsActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "space_is_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method space_is_active" } + } + } + + val spaceSetActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "space_set_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method space_set_active" } + } + } + + val spaceSetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DServer".cstr.ptr, + "space_set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method space_set_param" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DShapeQueryParameters.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DShapeQueryParameters.kt index ad6d4371..6b303ce5 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DShapeQueryParameters.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DShapeQueryParameters.kt @@ -293,124 +293,160 @@ open class Physics2DShapeQueryParameters( * Container for method_bind pointers for Physics2DShapeQueryParameters */ private object __method_bind { - val getCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, - "get_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_layer" } - } - val getExclude: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, - "get_exclude".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_exclude" } - } - val getMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, - "get_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_margin" } - } - val getMotion: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, - "get_motion".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_motion" } - } - val getShapeRid: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, - "get_shape_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shape_rid" } - } - val getTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, - "get_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_transform" } - } - val isCollideWithAreasEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, - "is_collide_with_areas_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_collide_with_areas_enabled" } - } - val isCollideWithBodiesEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, - "is_collide_with_bodies_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_collide_with_bodies_enabled" } - } - val setCollideWithAreas: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, - "set_collide_with_areas".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collide_with_areas" } - } - val setCollideWithBodies: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, - "set_collide_with_bodies".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collide_with_bodies" } - } - val setCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, - "set_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_layer" } - } - val setExclude: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, - "set_exclude".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_exclude" } - } - val setMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, - "set_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_margin" } - } - val setMotion: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, - "set_motion".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_motion" } - } - val setShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, - "set_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shape" } - } - val setShapeRid: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, - "set_shape_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shape_rid" } - } - val setTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, - "set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_transform" } - }} + val getCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, + "get_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_layer" } + } + } + + val getExclude: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, + "get_exclude".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_exclude" } + } + } + + val getMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, + "get_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_margin" } + } + } + + val getMotion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, + "get_motion".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_motion" } + } + } + + val getShapeRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, + "get_shape_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shape_rid" } + } + } + + val getTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, + "get_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_transform" } + } + } + + val isCollideWithAreasEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, + "is_collide_with_areas_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_collide_with_areas_enabled" + } + } + } + + val isCollideWithBodiesEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, + "is_collide_with_bodies_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_collide_with_bodies_enabled" + } + } + } + + val setCollideWithAreas: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, + "set_collide_with_areas".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collide_with_areas" } + } + } + + val setCollideWithBodies: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, + "set_collide_with_bodies".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collide_with_bodies" } + } + } + + val setCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, + "set_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_layer" } + } + } + + val setExclude: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, + "set_exclude".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_exclude" } + } + } + + val setMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, + "set_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_margin" } + } + } + + val setMotion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, + "set_motion".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_motion" } + } + } + + val setShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, + "set_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shape" } + } + } + + val setShapeRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, + "set_shape_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shape_rid" } + } + } + + val setTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryParameters".cstr.ptr, + "set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_transform" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DShapeQueryResult.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DShapeQueryResult.kt index b3a9a01b..e247cb24 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DShapeQueryResult.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DShapeQueryResult.kt @@ -96,40 +96,50 @@ open class Physics2DShapeQueryResult( * Container for method_bind pointers for Physics2DShapeQueryResult */ private object __method_bind { - val getResultCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryResult".cstr.ptr, - "get_result_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_result_count" } - } - val getResultObject: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryResult".cstr.ptr, - "get_result_object".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_result_object" } - } - val getResultObjectId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryResult".cstr.ptr, - "get_result_object_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_result_object_id" } - } - val getResultObjectShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryResult".cstr.ptr, - "get_result_object_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_result_object_shape" } - } - val getResultRid: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryResult".cstr.ptr, - "get_result_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_result_rid" } - }} + val getResultCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryResult".cstr.ptr, + "get_result_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_result_count" } + } + } + + val getResultObject: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryResult".cstr.ptr, + "get_result_object".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_result_object" } + } + } + + val getResultObjectId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryResult".cstr.ptr, + "get_result_object_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_result_object_id" } + } + } + + val getResultObjectShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryResult".cstr.ptr, + "get_result_object_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_result_object_shape" } + } + } + + val getResultRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DShapeQueryResult".cstr.ptr, + "get_result_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_result_rid" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DTestMotionResult.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DTestMotionResult.kt index 2257bb10..2f323c8e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DTestMotionResult.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Physics2DTestMotionResult.kt @@ -194,68 +194,86 @@ open class Physics2DTestMotionResult( * Container for method_bind pointers for Physics2DTestMotionResult */ private object __method_bind { - val getCollider: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DTestMotionResult".cstr.ptr, - "get_collider".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider" } - } - val getColliderId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DTestMotionResult".cstr.ptr, - "get_collider_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider_id" } - } - val getColliderRid: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DTestMotionResult".cstr.ptr, - "get_collider_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider_rid" } - } - val getColliderShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DTestMotionResult".cstr.ptr, - "get_collider_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider_shape" } - } - val getColliderVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DTestMotionResult".cstr.ptr, - "get_collider_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider_velocity" } - } - val getCollisionNormal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DTestMotionResult".cstr.ptr, - "get_collision_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_normal" } - } - val getCollisionPoint: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DTestMotionResult".cstr.ptr, - "get_collision_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_point" } - } - val getMotion: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DTestMotionResult".cstr.ptr, - "get_motion".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_motion" } - } - val getMotionRemainder: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DTestMotionResult".cstr.ptr, - "get_motion_remainder".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_motion_remainder" } - }} + val getCollider: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DTestMotionResult".cstr.ptr, + "get_collider".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider" } + } + } + + val getColliderId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DTestMotionResult".cstr.ptr, + "get_collider_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider_id" } + } + } + + val getColliderRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DTestMotionResult".cstr.ptr, + "get_collider_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider_rid" } + } + } + + val getColliderShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DTestMotionResult".cstr.ptr, + "get_collider_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider_shape" } + } + } + + val getColliderVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DTestMotionResult".cstr.ptr, + "get_collider_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider_velocity" } + } + } + + val getCollisionNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DTestMotionResult".cstr.ptr, + "get_collision_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_normal" } + } + } + + val getCollisionPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DTestMotionResult".cstr.ptr, + "get_collision_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_point" } + } + } + + val getMotion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DTestMotionResult".cstr.ptr, + "get_motion".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_motion" } + } + } + + val getMotionRemainder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Physics2DTestMotionResult".cstr.ptr, + "get_motion_remainder".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_motion_remainder" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsBody.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsBody.kt index 8fc0322d..37bb6b48 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsBody.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsBody.kt @@ -166,82 +166,105 @@ open class PhysicsBody( * Container for method_bind pointers for PhysicsBody */ private object __method_bind { - val addCollisionExceptionWith: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, - "add_collision_exception_with".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_collision_exception_with" } - } - val getCollisionExceptions: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, - "get_collision_exceptions".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_exceptions" } - } - val getCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, - "get_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_layer" } - } - val getCollisionLayerBit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, - "get_collision_layer_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_layer_bit" } - } - val getCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, - "get_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } - } - val getCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, - "get_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } - } - val removeCollisionExceptionWith: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, - "remove_collision_exception_with".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_collision_exception_with" } - } - val setCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, - "set_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_layer" } - } - val setCollisionLayerBit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, - "set_collision_layer_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_layer_bit" } - } - val setCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, - "set_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } - } - val setCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, - "set_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } - }} + val addCollisionExceptionWith: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, + "add_collision_exception_with".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_collision_exception_with" } + } + } + + val getCollisionExceptions: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, + "get_collision_exceptions".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_exceptions" } + } + } + + val getCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, + "get_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_layer" } + } + } + + val getCollisionLayerBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, + "get_collision_layer_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_layer_bit" } + } + } + + val getCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, + "get_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } + } + } + + val getCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, + "get_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } + } + } + + val removeCollisionExceptionWith: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, + "remove_collision_exception_with".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method remove_collision_exception_with" } + } + } + + val setCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, + "set_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_layer" } + } + } + + val setCollisionLayerBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, + "set_collision_layer_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_layer_bit" } + } + } + + val setCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, + "set_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } + } + } + + val setCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody".cstr.ptr, + "set_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsBody2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsBody2D.kt index 6de00960..bd9b29db 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsBody2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsBody2D.kt @@ -166,82 +166,105 @@ open class PhysicsBody2D( * Container for method_bind pointers for PhysicsBody2D */ private object __method_bind { - val addCollisionExceptionWith: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, - "add_collision_exception_with".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_collision_exception_with" } - } - val getCollisionExceptions: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, - "get_collision_exceptions".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_exceptions" } - } - val getCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, - "get_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_layer" } - } - val getCollisionLayerBit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, - "get_collision_layer_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_layer_bit" } - } - val getCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, - "get_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } - } - val getCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, - "get_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } - } - val removeCollisionExceptionWith: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, - "remove_collision_exception_with".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_collision_exception_with" } - } - val setCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, - "set_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_layer" } - } - val setCollisionLayerBit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, - "set_collision_layer_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_layer_bit" } - } - val setCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, - "set_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } - } - val setCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, - "set_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } - }} + val addCollisionExceptionWith: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, + "add_collision_exception_with".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_collision_exception_with" } + } + } + + val getCollisionExceptions: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, + "get_collision_exceptions".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_exceptions" } + } + } + + val getCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, + "get_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_layer" } + } + } + + val getCollisionLayerBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, + "get_collision_layer_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_layer_bit" } + } + } + + val getCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, + "get_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } + } + } + + val getCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, + "get_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } + } + } + + val removeCollisionExceptionWith: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, + "remove_collision_exception_with".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method remove_collision_exception_with" } + } + } + + val setCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, + "set_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_layer" } + } + } + + val setCollisionLayerBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, + "set_collision_layer_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_layer_bit" } + } + } + + val setCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, + "set_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } + } + } + + val setCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsBody2D".cstr.ptr, + "set_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsDirectBodyState.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsDirectBodyState.kt index 2a18e6e5..15713b3e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsDirectBodyState.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsDirectBodyState.kt @@ -488,251 +488,322 @@ open class PhysicsDirectBodyState( * Container for method_bind pointers for PhysicsDirectBodyState */ private object __method_bind { - val addCentralForce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "add_central_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_central_force" } - } - val addForce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "add_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_force" } - } - val addTorque: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "add_torque".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_torque" } - } - val applyCentralImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "apply_central_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method apply_central_impulse" } - } - val applyImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "apply_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method apply_impulse" } - } - val applyTorqueImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "apply_torque_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method apply_torque_impulse" } - } - val getAngularVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_angular_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_angular_velocity" } - } - val getCenterOfMass: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_center_of_mass".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_center_of_mass" } - } - val getContactCollider: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_contact_collider".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_contact_collider" } - } - val getContactColliderId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_contact_collider_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_contact_collider_id" } - } - val getContactColliderObject: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_contact_collider_object".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_contact_collider_object" } - } - val getContactColliderPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_contact_collider_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_contact_collider_position" } - } - val getContactColliderShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_contact_collider_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_contact_collider_shape" } - } - val getContactColliderVelocityAtPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_contact_collider_velocity_at_position".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method get_contact_collider_velocity_at_position" } - } - val getContactCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_contact_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_contact_count" } - } - val getContactImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_contact_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_contact_impulse" } - } - val getContactLocalNormal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_contact_local_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_contact_local_normal" } - } - val getContactLocalPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_contact_local_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_contact_local_position" } - } - val getContactLocalShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_contact_local_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_contact_local_shape" } - } - val getInverseInertia: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_inverse_inertia".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_inverse_inertia" } - } - val getInverseMass: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_inverse_mass".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_inverse_mass" } - } - val getLinearVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_linear_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_linear_velocity" } - } - val getPrincipalInertiaAxes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_principal_inertia_axes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_principal_inertia_axes" } - } - val getSpaceState: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_space_state".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_space_state" } - } - val getStep: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_step".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_step" } - } - val getTotalAngularDamp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_total_angular_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_total_angular_damp" } - } - val getTotalGravity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_total_gravity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_total_gravity" } - } - val getTotalLinearDamp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_total_linear_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_total_linear_damp" } - } - val getTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "get_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_transform" } - } - val integrateForces: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "integrate_forces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method integrate_forces" } - } - val isSleeping: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "is_sleeping".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_sleeping" } - } - val setAngularVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "set_angular_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_angular_velocity" } - } - val setLinearVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "set_linear_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_linear_velocity" } - } - val setSleepState: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "set_sleep_state".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sleep_state" } - } - val setTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, - "set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_transform" } - }} + val addCentralForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "add_central_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_central_force" } + } + } + + val addForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "add_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_force" } + } + } + + val addTorque: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "add_torque".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_torque" } + } + } + + val applyCentralImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "apply_central_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method apply_central_impulse" } + } + } + + val applyImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "apply_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method apply_impulse" } + } + } + + val applyTorqueImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "apply_torque_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method apply_torque_impulse" } + } + } + + val getAngularVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_angular_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_angular_velocity" } + } + } + + val getCenterOfMass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_center_of_mass".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_center_of_mass" } + } + } + + val getContactCollider: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_contact_collider".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_contact_collider" } + } + } + + val getContactColliderId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_contact_collider_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_contact_collider_id" } + } + } + + val getContactColliderObject: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_contact_collider_object".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_contact_collider_object" } + } + } + + val getContactColliderPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_contact_collider_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_contact_collider_position" + } + } + } + + val getContactColliderShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_contact_collider_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_contact_collider_shape" } + } + } + + val getContactColliderVelocityAtPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_contact_collider_velocity_at_position".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_contact_collider_velocity_at_position" } + } + } + + val getContactCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_contact_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_contact_count" } + } + } + + val getContactImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_contact_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_contact_impulse" } + } + } + + val getContactLocalNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_contact_local_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_contact_local_normal" } + } + } + + val getContactLocalPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_contact_local_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_contact_local_position" } + } + } + + val getContactLocalShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_contact_local_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_contact_local_shape" } + } + } + + val getInverseInertia: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_inverse_inertia".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_inverse_inertia" } + } + } + + val getInverseMass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_inverse_mass".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_inverse_mass" } + } + } + + val getLinearVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_linear_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_linear_velocity" } + } + } + + val getPrincipalInertiaAxes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_principal_inertia_axes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_principal_inertia_axes" } + } + } + + val getSpaceState: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_space_state".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_space_state" } + } + } + + val getStep: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_step".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_step" } + } + } + + val getTotalAngularDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_total_angular_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_total_angular_damp" } + } + } + + val getTotalGravity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_total_gravity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_total_gravity" } + } + } + + val getTotalLinearDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_total_linear_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_total_linear_damp" } + } + } + + val getTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "get_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_transform" } + } + } + + val integrateForces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "integrate_forces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method integrate_forces" } + } + } + + val isSleeping: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "is_sleeping".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_sleeping" } + } + } + + val setAngularVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "set_angular_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_angular_velocity" } + } + } + + val setLinearVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "set_linear_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_linear_velocity" } + } + } + + val setSleepState: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "set_sleep_state".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sleep_state" } + } + } + + val setTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectBodyState".cstr.ptr, + "set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_transform" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsDirectSpaceState.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsDirectSpaceState.kt index 70b0e18c..84ceaf86 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsDirectSpaceState.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsDirectSpaceState.kt @@ -123,40 +123,50 @@ open class PhysicsDirectSpaceState( * Container for method_bind pointers for PhysicsDirectSpaceState */ private object __method_bind { - val castMotion: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectSpaceState".cstr.ptr, - "cast_motion".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cast_motion" } - } - val collideShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectSpaceState".cstr.ptr, - "collide_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method collide_shape" } - } - val getRestInfo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectSpaceState".cstr.ptr, - "get_rest_info".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rest_info" } - } - val intersectRay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectSpaceState".cstr.ptr, - "intersect_ray".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method intersect_ray" } - } - val intersectShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectSpaceState".cstr.ptr, - "intersect_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method intersect_shape" } - }} + val castMotion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectSpaceState".cstr.ptr, + "cast_motion".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cast_motion" } + } + } + + val collideShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectSpaceState".cstr.ptr, + "collide_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method collide_shape" } + } + } + + val getRestInfo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectSpaceState".cstr.ptr, + "get_rest_info".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rest_info" } + } + } + + val intersectRay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectSpaceState".cstr.ptr, + "intersect_ray".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method intersect_ray" } + } + } + + val intersectShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsDirectSpaceState".cstr.ptr, + "intersect_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method intersect_shape" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsMaterial.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsMaterial.kt index c20c439a..09d04111 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsMaterial.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsMaterial.kt @@ -150,61 +150,77 @@ open class PhysicsMaterial( * Container for method_bind pointers for PhysicsMaterial */ private object __method_bind { - val getBounce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsMaterial".cstr.ptr, - "get_bounce".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bounce" } - } - val getFriction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsMaterial".cstr.ptr, - "get_friction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_friction" } - } - val isAbsorbent: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsMaterial".cstr.ptr, - "is_absorbent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_absorbent" } - } - val isRough: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsMaterial".cstr.ptr, - "is_rough".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_rough" } - } - val setAbsorbent: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsMaterial".cstr.ptr, - "set_absorbent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_absorbent" } - } - val setBounce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsMaterial".cstr.ptr, - "set_bounce".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bounce" } - } - val setFriction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsMaterial".cstr.ptr, - "set_friction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_friction" } - } - val setRough: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsMaterial".cstr.ptr, - "set_rough".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rough" } - }} + val getBounce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsMaterial".cstr.ptr, + "get_bounce".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bounce" } + } + } + + val getFriction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsMaterial".cstr.ptr, + "get_friction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_friction" } + } + } + + val isAbsorbent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsMaterial".cstr.ptr, + "is_absorbent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_absorbent" } + } + } + + val isRough: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsMaterial".cstr.ptr, + "is_rough".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_rough" } + } + } + + val setAbsorbent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsMaterial".cstr.ptr, + "set_absorbent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_absorbent" } + } + } + + val setBounce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsMaterial".cstr.ptr, + "set_bounce".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bounce" } + } + } + + val setFriction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsMaterial".cstr.ptr, + "set_friction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_friction" } + } + } + + val setRough: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsMaterial".cstr.ptr, + "set_rough".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rough" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsServer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsServer.kt index fea37c71..18cbed7f 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsServer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsServer.kt @@ -1431,801 +1431,1036 @@ open class PhysicsServerInternal( * Container for method_bind pointers for PhysicsServer */ private object __method_bind { - val areaAddShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_add_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_add_shape" } - } - val areaAttachObjectInstanceId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_attach_object_instance_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_attach_object_instance_id" } - } - val areaClearShapes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_clear_shapes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_clear_shapes" } - } - val areaCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_create" } - } - val areaGetObjectInstanceId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_get_object_instance_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_get_object_instance_id" } - } - val areaGetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_get_param" } - } - val areaGetShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_get_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_get_shape" } - } - val areaGetShapeCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_get_shape_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_get_shape_count" } - } - val areaGetShapeTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_get_shape_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_get_shape_transform" } - } - val areaGetSpace: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_get_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_get_space" } - } - val areaGetSpaceOverrideMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_get_space_override_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_get_space_override_mode" } - } - val areaGetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_get_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_get_transform" } - } - val areaIsRayPickable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_is_ray_pickable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_is_ray_pickable" } - } - val areaRemoveShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_remove_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_remove_shape" } - } - val areaSetAreaMonitorCallback: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_set_area_monitor_callback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_area_monitor_callback" } - } - val areaSetCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_set_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_collision_layer" } - } - val areaSetCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_set_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_collision_mask" } - } - val areaSetMonitorCallback: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_set_monitor_callback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_monitor_callback" } - } - val areaSetMonitorable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_set_monitorable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_monitorable" } - } - val areaSetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_param" } - } - val areaSetRayPickable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_set_ray_pickable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_ray_pickable" } - } - val areaSetShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_set_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_shape" } - } - val areaSetShapeDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_set_shape_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_shape_disabled" } - } - val areaSetShapeTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_set_shape_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_shape_transform" } - } - val areaSetSpace: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_set_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_space" } - } - val areaSetSpaceOverrideMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_set_space_override_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_space_override_mode" } - } - val areaSetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "area_set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method area_set_transform" } - } - val bodyAddCentralForce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_add_central_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_add_central_force" } - } - val bodyAddCollisionException: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_add_collision_exception".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_add_collision_exception" } - } - val bodyAddForce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_add_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_add_force" } - } - val bodyAddShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_add_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_add_shape" } - } - val bodyAddTorque: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_add_torque".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_add_torque" } - } - val bodyApplyCentralImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_apply_central_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_apply_central_impulse" } - } - val bodyApplyImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_apply_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_apply_impulse" } - } - val bodyApplyTorqueImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_apply_torque_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_apply_torque_impulse" } - } - val bodyAttachObjectInstanceId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_attach_object_instance_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_attach_object_instance_id" } - } - val bodyClearShapes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_clear_shapes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_clear_shapes" } - } - val bodyCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_create" } - } - val bodyGetCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_get_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_collision_layer" } - } - val bodyGetCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_get_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_collision_mask" } - } - val bodyGetDirectState: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_get_direct_state".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_direct_state" } - } - val bodyGetKinematicSafeMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_get_kinematic_safe_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_kinematic_safe_margin" } - } - val bodyGetMaxContactsReported: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_get_max_contacts_reported".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_max_contacts_reported" } - } - val bodyGetMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_get_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_mode" } - } - val bodyGetObjectInstanceId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_get_object_instance_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_object_instance_id" } - } - val bodyGetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_param" } - } - val bodyGetShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_get_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_shape" } - } - val bodyGetShapeCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_get_shape_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_shape_count" } - } - val bodyGetShapeTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_get_shape_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_shape_transform" } - } - val bodyGetSpace: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_get_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_space" } - } - val bodyGetState: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_get_state".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_get_state" } - } - val bodyIsAxisLocked: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_is_axis_locked".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_is_axis_locked" } - } - val bodyIsContinuousCollisionDetectionEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_is_continuous_collision_detection_enabled".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method body_is_continuous_collision_detection_enabled" } - } - val bodyIsOmittingForceIntegration: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_is_omitting_force_integration".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_is_omitting_force_integration" + val areaAddShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_add_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_add_shape" } } - } - val bodyIsRayPickable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_is_ray_pickable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_is_ray_pickable" } - } - val bodyRemoveCollisionException: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_remove_collision_exception".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_remove_collision_exception" } - } - val bodyRemoveShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_remove_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_remove_shape" } - } - val bodySetAxisLock: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_set_axis_lock".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_axis_lock" } - } - val bodySetAxisVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_set_axis_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_axis_velocity" } - } - val bodySetCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_set_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_collision_layer" } - } - val bodySetCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_set_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_collision_mask" } - } - val bodySetEnableContinuousCollisionDetection: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_set_enable_continuous_collision_detection".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method body_set_enable_continuous_collision_detection" } - } - val bodySetForceIntegrationCallback: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_set_force_integration_callback".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method body_set_force_integration_callback" } - } - val bodySetKinematicSafeMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_set_kinematic_safe_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_kinematic_safe_margin" } - } - val bodySetMaxContactsReported: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_set_max_contacts_reported".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_max_contacts_reported" } - } - val bodySetMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_set_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_mode" } - } - val bodySetOmitForceIntegration: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_set_omit_force_integration".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_omit_force_integration" } - } - val bodySetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_param" } - } - val bodySetRayPickable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_set_ray_pickable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_ray_pickable" } - } - val bodySetShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_set_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_shape" } - } - val bodySetShapeDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_set_shape_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_shape_disabled" } - } - val bodySetShapeTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_set_shape_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_shape_transform" } - } - val bodySetSpace: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_set_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_space" } - } - val bodySetState: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "body_set_state".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method body_set_state" } - } - val coneTwistJointGetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "cone_twist_joint_get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cone_twist_joint_get_param" } - } - val coneTwistJointSetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "cone_twist_joint_set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cone_twist_joint_set_param" } - } - val freeRid: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "free_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method free_rid" } - } - val generic6dofJointGetFlag: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "generic_6dof_joint_get_flag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method generic_6dof_joint_get_flag" } - } - val generic6dofJointGetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "generic_6dof_joint_get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method generic_6dof_joint_get_param" } - } - val generic6dofJointSetFlag: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "generic_6dof_joint_set_flag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method generic_6dof_joint_set_flag" } - } - val generic6dofJointSetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "generic_6dof_joint_set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method generic_6dof_joint_set_param" } - } - val getProcessInfo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "get_process_info".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_process_info" } - } - val hingeJointGetFlag: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "hinge_joint_get_flag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method hinge_joint_get_flag" } - } - val hingeJointGetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "hinge_joint_get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method hinge_joint_get_param" } - } - val hingeJointSetFlag: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "hinge_joint_set_flag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method hinge_joint_set_flag" } - } - val hingeJointSetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "hinge_joint_set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method hinge_joint_set_param" } - } - val jointCreateConeTwist: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "joint_create_cone_twist".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method joint_create_cone_twist" } - } - val jointCreateGeneric6dof: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "joint_create_generic_6dof".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method joint_create_generic_6dof" } - } - val jointCreateHinge: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "joint_create_hinge".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method joint_create_hinge" } - } - val jointCreatePin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "joint_create_pin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method joint_create_pin" } - } - val jointCreateSlider: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "joint_create_slider".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method joint_create_slider" } - } - val jointGetSolverPriority: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "joint_get_solver_priority".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method joint_get_solver_priority" } - } - val jointGetType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "joint_get_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method joint_get_type" } - } - val jointSetSolverPriority: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "joint_set_solver_priority".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method joint_set_solver_priority" } - } - val pinJointGetLocalA: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "pin_joint_get_local_a".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method pin_joint_get_local_a" } - } - val pinJointGetLocalB: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "pin_joint_get_local_b".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method pin_joint_get_local_b" } - } - val pinJointGetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "pin_joint_get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method pin_joint_get_param" } - } - val pinJointSetLocalA: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "pin_joint_set_local_a".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method pin_joint_set_local_a" } - } - val pinJointSetLocalB: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "pin_joint_set_local_b".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method pin_joint_set_local_b" } - } - val pinJointSetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "pin_joint_set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method pin_joint_set_param" } - } - val setActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "set_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_active" } - } - val shapeCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "shape_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_create" } - } - val shapeGetData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "shape_get_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_get_data" } - } - val shapeGetType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "shape_get_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_get_type" } - } - val shapeSetData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "shape_set_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shape_set_data" } - } - val sliderJointGetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "slider_joint_get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method slider_joint_get_param" } - } - val sliderJointSetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "slider_joint_set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method slider_joint_set_param" } - } - val spaceCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "space_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method space_create" } - } - val spaceGetDirectState: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "space_get_direct_state".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method space_get_direct_state" } - } - val spaceGetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "space_get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method space_get_param" } - } - val spaceIsActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "space_is_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method space_is_active" } - } - val spaceSetActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "space_set_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method space_set_active" } - } - val spaceSetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, - "space_set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method space_set_param" } - }} + } + + val areaAttachObjectInstanceId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_attach_object_instance_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_attach_object_instance_id" + } + } + } + + val areaClearShapes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_clear_shapes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_clear_shapes" } + } + } + + val areaCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_create" } + } + } + + val areaGetObjectInstanceId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_get_object_instance_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_get_object_instance_id" } + } + } + + val areaGetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_get_param" } + } + } + + val areaGetShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_get_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_get_shape" } + } + } + + val areaGetShapeCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_get_shape_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_get_shape_count" } + } + } + + val areaGetShapeTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_get_shape_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_get_shape_transform" } + } + } + + val areaGetSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_get_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_get_space" } + } + } + + val areaGetSpaceOverrideMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_get_space_override_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_get_space_override_mode" } + } + } + + val areaGetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_get_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_get_transform" } + } + } + + val areaIsRayPickable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_is_ray_pickable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_is_ray_pickable" } + } + } + + val areaRemoveShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_remove_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_remove_shape" } + } + } + + val areaSetAreaMonitorCallback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_set_area_monitor_callback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_area_monitor_callback" + } + } + } + + val areaSetCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_set_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_collision_layer" } + } + } + + val areaSetCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_set_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_collision_mask" } + } + } + + val areaSetMonitorCallback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_set_monitor_callback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_monitor_callback" } + } + } + + val areaSetMonitorable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_set_monitorable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_monitorable" } + } + } + + val areaSetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_param" } + } + } + + val areaSetRayPickable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_set_ray_pickable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_ray_pickable" } + } + } + + val areaSetShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_set_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_shape" } + } + } + + val areaSetShapeDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_set_shape_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_shape_disabled" } + } + } + + val areaSetShapeTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_set_shape_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_shape_transform" } + } + } + + val areaSetSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_set_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_space" } + } + } + + val areaSetSpaceOverrideMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_set_space_override_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_space_override_mode" } + } + } + + val areaSetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "area_set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method area_set_transform" } + } + } + + val bodyAddCentralForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_add_central_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_add_central_force" } + } + } + + val bodyAddCollisionException: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_add_collision_exception".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_add_collision_exception" } + } + } + + val bodyAddForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_add_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_add_force" } + } + } + + val bodyAddShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_add_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_add_shape" } + } + } + + val bodyAddTorque: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_add_torque".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_add_torque" } + } + } + + val bodyApplyCentralImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_apply_central_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_apply_central_impulse" } + } + } + + val bodyApplyImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_apply_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_apply_impulse" } + } + } + + val bodyApplyTorqueImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_apply_torque_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_apply_torque_impulse" } + } + } + + val bodyAttachObjectInstanceId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_attach_object_instance_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_attach_object_instance_id" + } + } + } + + val bodyClearShapes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_clear_shapes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_clear_shapes" } + } + } + + val bodyCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_create" } + } + } + + val bodyGetCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_get_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_collision_layer" } + } + } + + val bodyGetCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_get_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_collision_mask" } + } + } + + val bodyGetDirectState: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_get_direct_state".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_direct_state" } + } + } + + val bodyGetKinematicSafeMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_get_kinematic_safe_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_kinematic_safe_margin" + } + } + } + + val bodyGetMaxContactsReported: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_get_max_contacts_reported".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_max_contacts_reported" + } + } + } + + val bodyGetMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_get_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_mode" } + } + } + + val bodyGetObjectInstanceId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_get_object_instance_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_object_instance_id" } + } + } + + val bodyGetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_param" } + } + } + + val bodyGetShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_get_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_shape" } + } + } + + val bodyGetShapeCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_get_shape_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_shape_count" } + } + } + + val bodyGetShapeTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_get_shape_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_shape_transform" } + } + } + + val bodyGetSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_get_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_space" } + } + } + + val bodyGetState: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_get_state".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_get_state" } + } + } + + val bodyIsAxisLocked: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_is_axis_locked".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_is_axis_locked" } + } + } + + val bodyIsContinuousCollisionDetectionEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_is_continuous_collision_detection_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method body_is_continuous_collision_detection_enabled" } + } + } + + val bodyIsOmittingForceIntegration: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_is_omitting_force_integration".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method body_is_omitting_force_integration" } + } + } + + val bodyIsRayPickable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_is_ray_pickable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_is_ray_pickable" } + } + } + + val bodyRemoveCollisionException: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_remove_collision_exception".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method body_remove_collision_exception" } + } + } + + val bodyRemoveShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_remove_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_remove_shape" } + } + } + + val bodySetAxisLock: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_set_axis_lock".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_axis_lock" } + } + } + + val bodySetAxisVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_set_axis_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_axis_velocity" } + } + } + + val bodySetCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_set_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_collision_layer" } + } + } + + val bodySetCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_set_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_collision_mask" } + } + } + + val bodySetEnableContinuousCollisionDetection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_set_enable_continuous_collision_detection".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method body_set_enable_continuous_collision_detection" } + } + } + + val bodySetForceIntegrationCallback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_set_force_integration_callback".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method body_set_force_integration_callback" } + } + } + + val bodySetKinematicSafeMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_set_kinematic_safe_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_kinematic_safe_margin" + } + } + } + + val bodySetMaxContactsReported: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_set_max_contacts_reported".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_max_contacts_reported" + } + } + } + + val bodySetMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_set_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_mode" } + } + } + + val bodySetOmitForceIntegration: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_set_omit_force_integration".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method body_set_omit_force_integration" } + } + } + + val bodySetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_param" } + } + } + + val bodySetRayPickable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_set_ray_pickable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_ray_pickable" } + } + } + + val bodySetShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_set_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_shape" } + } + } + + val bodySetShapeDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_set_shape_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_shape_disabled" } + } + } + + val bodySetShapeTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_set_shape_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_shape_transform" } + } + } + + val bodySetSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_set_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_space" } + } + } + + val bodySetState: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "body_set_state".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method body_set_state" } + } + } + + val coneTwistJointGetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "cone_twist_joint_get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cone_twist_joint_get_param" } + } + } + + val coneTwistJointSetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "cone_twist_joint_set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cone_twist_joint_set_param" } + } + } + + val freeRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "free_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method free_rid" } + } + } + + val generic6dofJointGetFlag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "generic_6dof_joint_get_flag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method generic_6dof_joint_get_flag" } + } + } + + val generic6dofJointGetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "generic_6dof_joint_get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method generic_6dof_joint_get_param" } + } + } + + val generic6dofJointSetFlag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "generic_6dof_joint_set_flag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method generic_6dof_joint_set_flag" } + } + } + + val generic6dofJointSetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "generic_6dof_joint_set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method generic_6dof_joint_set_param" } + } + } + + val getProcessInfo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "get_process_info".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_process_info" } + } + } + + val hingeJointGetFlag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "hinge_joint_get_flag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method hinge_joint_get_flag" } + } + } + + val hingeJointGetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "hinge_joint_get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method hinge_joint_get_param" } + } + } + + val hingeJointSetFlag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "hinge_joint_set_flag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method hinge_joint_set_flag" } + } + } + + val hingeJointSetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "hinge_joint_set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method hinge_joint_set_param" } + } + } + + val jointCreateConeTwist: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "joint_create_cone_twist".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method joint_create_cone_twist" } + } + } + + val jointCreateGeneric6dof: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "joint_create_generic_6dof".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method joint_create_generic_6dof" } + } + } + + val jointCreateHinge: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "joint_create_hinge".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method joint_create_hinge" } + } + } + + val jointCreatePin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "joint_create_pin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method joint_create_pin" } + } + } + + val jointCreateSlider: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "joint_create_slider".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method joint_create_slider" } + } + } + + val jointGetSolverPriority: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "joint_get_solver_priority".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method joint_get_solver_priority" } + } + } + + val jointGetType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "joint_get_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method joint_get_type" } + } + } + + val jointSetSolverPriority: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "joint_set_solver_priority".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method joint_set_solver_priority" } + } + } + + val pinJointGetLocalA: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "pin_joint_get_local_a".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method pin_joint_get_local_a" } + } + } + + val pinJointGetLocalB: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "pin_joint_get_local_b".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method pin_joint_get_local_b" } + } + } + + val pinJointGetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "pin_joint_get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method pin_joint_get_param" } + } + } + + val pinJointSetLocalA: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "pin_joint_set_local_a".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method pin_joint_set_local_a" } + } + } + + val pinJointSetLocalB: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "pin_joint_set_local_b".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method pin_joint_set_local_b" } + } + } + + val pinJointSetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "pin_joint_set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method pin_joint_set_param" } + } + } + + val setActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "set_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_active" } + } + } + + val shapeCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "shape_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_create" } + } + } + + val shapeGetData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "shape_get_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_get_data" } + } + } + + val shapeGetType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "shape_get_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_get_type" } + } + } + + val shapeSetData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "shape_set_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shape_set_data" } + } + } + + val sliderJointGetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "slider_joint_get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method slider_joint_get_param" } + } + } + + val sliderJointSetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "slider_joint_set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method slider_joint_set_param" } + } + } + + val spaceCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "space_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method space_create" } + } + } + + val spaceGetDirectState: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "space_get_direct_state".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method space_get_direct_state" } + } + } + + val spaceGetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "space_get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method space_get_param" } + } + } + + val spaceIsActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "space_is_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method space_is_active" } + } + } + + val spaceSetActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "space_set_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method space_set_active" } + } + } + + val spaceSetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsServer".cstr.ptr, + "space_set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method space_set_param" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsShapeQueryParameters.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsShapeQueryParameters.kt index bea3834b..44ae899c 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsShapeQueryParameters.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsShapeQueryParameters.kt @@ -257,110 +257,142 @@ open class PhysicsShapeQueryParameters( * Container for method_bind pointers for PhysicsShapeQueryParameters */ private object __method_bind { - val getCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, - "get_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } - } - val getExclude: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, - "get_exclude".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_exclude" } - } - val getMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, - "get_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_margin" } - } - val getShapeRid: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, - "get_shape_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shape_rid" } - } - val getTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, - "get_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_transform" } - } - val isCollideWithAreasEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, - "is_collide_with_areas_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_collide_with_areas_enabled" } - } - val isCollideWithBodiesEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, - "is_collide_with_bodies_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_collide_with_bodies_enabled" } - } - val setCollideWithAreas: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, - "set_collide_with_areas".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collide_with_areas" } - } - val setCollideWithBodies: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, - "set_collide_with_bodies".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collide_with_bodies" } - } - val setCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, - "set_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } - } - val setExclude: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, - "set_exclude".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_exclude" } - } - val setMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, - "set_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_margin" } - } - val setShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, - "set_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shape" } - } - val setShapeRid: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, - "set_shape_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shape_rid" } - } - val setTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, - "set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_transform" } - }} + val getCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, + "get_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } + } + } + + val getExclude: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, + "get_exclude".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_exclude" } + } + } + + val getMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, + "get_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_margin" } + } + } + + val getShapeRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, + "get_shape_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shape_rid" } + } + } + + val getTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, + "get_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_transform" } + } + } + + val isCollideWithAreasEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, + "is_collide_with_areas_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_collide_with_areas_enabled" + } + } + } + + val isCollideWithBodiesEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, + "is_collide_with_bodies_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_collide_with_bodies_enabled" + } + } + } + + val setCollideWithAreas: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, + "set_collide_with_areas".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collide_with_areas" } + } + } + + val setCollideWithBodies: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, + "set_collide_with_bodies".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collide_with_bodies" } + } + } + + val setCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, + "set_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } + } + } + + val setExclude: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, + "set_exclude".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_exclude" } + } + } + + val setMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, + "set_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_margin" } + } + } + + val setShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, + "set_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shape" } + } + } + + val setShapeRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, + "set_shape_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shape_rid" } + } + } + + val setTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryParameters".cstr.ptr, + "set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_transform" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsShapeQueryResult.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsShapeQueryResult.kt index f7da8e92..f256ea99 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsShapeQueryResult.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PhysicsShapeQueryResult.kt @@ -96,40 +96,50 @@ open class PhysicsShapeQueryResult( * Container for method_bind pointers for PhysicsShapeQueryResult */ private object __method_bind { - val getResultCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryResult".cstr.ptr, - "get_result_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_result_count" } - } - val getResultObject: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryResult".cstr.ptr, - "get_result_object".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_result_object" } - } - val getResultObjectId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryResult".cstr.ptr, - "get_result_object_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_result_object_id" } - } - val getResultObjectShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryResult".cstr.ptr, - "get_result_object_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_result_object_shape" } - } - val getResultRid: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryResult".cstr.ptr, - "get_result_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_result_rid" } - }} + val getResultCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryResult".cstr.ptr, + "get_result_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_result_count" } + } + } + + val getResultObject: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryResult".cstr.ptr, + "get_result_object".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_result_object" } + } + } + + val getResultObjectId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryResult".cstr.ptr, + "get_result_object_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_result_object_id" } + } + } + + val getResultObjectShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryResult".cstr.ptr, + "get_result_object_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_result_object_shape" } + } + } + + val getResultRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PhysicsShapeQueryResult".cstr.ptr, + "get_result_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_result_rid" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PinJoint.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PinJoint.kt index a83cc5fb..3e61b5b0 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PinJoint.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PinJoint.kt @@ -114,17 +114,23 @@ open class PinJoint( * Container for method_bind pointers for PinJoint */ private object __method_bind { - val getParam: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PinJoint".cstr.ptr, - "get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_param" } - } - val setParam: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PinJoint".cstr.ptr, - "set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_param" } - }} + val getParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PinJoint".cstr.ptr, + "get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_param" } + } + } + + val setParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PinJoint".cstr.ptr, + "set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_param" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PinJoint2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PinJoint2D.kt index 8672f12c..bde80fad 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PinJoint2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PinJoint2D.kt @@ -73,17 +73,23 @@ open class PinJoint2D( * Container for method_bind pointers for PinJoint2D */ private object __method_bind { - val getSoftness: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PinJoint2D".cstr.ptr, - "get_softness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_softness" } - } - val setSoftness: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PinJoint2D".cstr.ptr, - "set_softness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_softness" } - }} + val getSoftness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PinJoint2D".cstr.ptr, + "get_softness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_softness" } + } + } + + val setSoftness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PinJoint2D".cstr.ptr, + "set_softness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_softness" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PlaneMesh.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PlaneMesh.kt index 8c0352e3..1a80f5b0 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PlaneMesh.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PlaneMesh.kt @@ -135,41 +135,59 @@ open class PlaneMesh( * Container for method_bind pointers for PlaneMesh */ private object __method_bind { - val getSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PlaneMesh".cstr.ptr, - "get_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_size" } - } - val getSubdivideDepth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PlaneMesh".cstr.ptr, - "get_subdivide_depth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_subdivide_depth" } - } - val getSubdivideWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PlaneMesh".cstr.ptr, - "get_subdivide_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_subdivide_width" } - } - val setSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PlaneMesh".cstr.ptr, - "set_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_size" } - } - val setSubdivideDepth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PlaneMesh".cstr.ptr, - "set_subdivide_depth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_subdivide_depth" } - } - val setSubdivideWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PlaneMesh".cstr.ptr, - "set_subdivide_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_subdivide_width" } - }} + val getSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PlaneMesh".cstr.ptr, + "get_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_size" } + } + } + + val getSubdivideDepth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PlaneMesh".cstr.ptr, + "get_subdivide_depth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_subdivide_depth" } + } + } + + val getSubdivideWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PlaneMesh".cstr.ptr, + "get_subdivide_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_subdivide_width" } + } + } + + val setSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PlaneMesh".cstr.ptr, + "set_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_size" } + } + } + + val setSubdivideDepth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PlaneMesh".cstr.ptr, + "set_subdivide_depth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_subdivide_depth" } + } + } + + val setSubdivideWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PlaneMesh".cstr.ptr, + "set_subdivide_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_subdivide_width" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PlaneShape.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PlaneShape.kt index df163a19..4c64f9ce 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PlaneShape.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PlaneShape.kt @@ -84,17 +84,23 @@ open class PlaneShape( * Container for method_bind pointers for PlaneShape */ private object __method_bind { - val getPlane: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PlaneShape".cstr.ptr, - "get_plane".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_plane" } - } - val setPlane: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PlaneShape".cstr.ptr, - "set_plane".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_plane" } - }} + val getPlane: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PlaneShape".cstr.ptr, + "get_plane".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_plane" } + } + } + + val setPlane: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PlaneShape".cstr.ptr, + "set_plane".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_plane" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PluginScript.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PluginScript.kt index e9ae9918..683612e6 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PluginScript.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PluginScript.kt @@ -55,12 +55,14 @@ open class PluginScript( * Container for method_bind pointers for PluginScript */ private object __method_bind { - val new: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PluginScript".cstr.ptr, - "new".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method new" } - }} + val new: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PluginScript".cstr.ptr, + "new".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method new" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Polygon2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Polygon2D.kt index 091e0978..a3765665 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Polygon2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Polygon2D.kt @@ -628,245 +628,365 @@ open class Polygon2D( * Container for method_bind pointers for Polygon2D */ private object __method_bind { - val addBone: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "add_bone".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_bone" } - } - val clearBones: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "clear_bones".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_bones" } - } - val eraseBone: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "erase_bone".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method erase_bone" } - } - val getAntialiased: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "get_antialiased".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_antialiased" } - } - val getBoneCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "get_bone_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bone_count" } - } - val getBonePath: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "get_bone_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bone_path" } - } - val getBoneWeights: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "get_bone_weights".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bone_weights" } - } - val getColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "get_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_color" } - } - val getInternalVertexCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "get_internal_vertex_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_internal_vertex_count" } - } - val getInvert: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "get_invert".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_invert" } - } - val getInvertBorder: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "get_invert_border".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_invert_border" } - } - val getOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "get_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_offset" } - } - val getPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "get_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_polygon" } - } - val getPolygons: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "get_polygons".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_polygons" } - } - val getSkeleton: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "get_skeleton".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_skeleton" } - } - val getTexture: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "get_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture" } - } - val getTextureOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "get_texture_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture_offset" } - } - val getTextureRotation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "get_texture_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture_rotation" } - } - val getTextureRotationDegrees: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "get_texture_rotation_degrees".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture_rotation_degrees" } - } - val getTextureScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "get_texture_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture_scale" } - } - val getUv: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "get_uv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_uv" } - } - val getVertexColors: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "get_vertex_colors".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vertex_colors" } - } - val setAntialiased: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "set_antialiased".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_antialiased" } - } - val setBonePath: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "set_bone_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bone_path" } - } - val setBoneWeights: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "set_bone_weights".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bone_weights" } - } - val setColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "set_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_color" } - } - val setInternalVertexCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "set_internal_vertex_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_internal_vertex_count" } - } - val setInvert: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "set_invert".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_invert" } - } - val setInvertBorder: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "set_invert_border".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_invert_border" } - } - val setOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "set_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_offset" } - } - val setPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "set_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_polygon" } - } - val setPolygons: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "set_polygons".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_polygons" } - } - val setSkeleton: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "set_skeleton".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_skeleton" } - } - val setTexture: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "set_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture" } - } - val setTextureOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "set_texture_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture_offset" } - } - val setTextureRotation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "set_texture_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture_rotation" } - } - val setTextureRotationDegrees: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "set_texture_rotation_degrees".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture_rotation_degrees" } - } - val setTextureScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "set_texture_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture_scale" } - } - val setUv: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "set_uv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_uv" } - } - val setVertexColors: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, - "set_vertex_colors".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_vertex_colors" } - }} + val addBone: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "add_bone".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_bone" } + } + } + + val clearBones: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "clear_bones".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_bones" } + } + } + + val eraseBone: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "erase_bone".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method erase_bone" } + } + } + + val getAntialiased: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "get_antialiased".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_antialiased" } + } + } + + val getBoneCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "get_bone_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bone_count" } + } + } + + val getBonePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "get_bone_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bone_path" } + } + } + + val getBoneWeights: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "get_bone_weights".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bone_weights" } + } + } + + val getColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "get_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_color" } + } + } + + val getInternalVertexCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "get_internal_vertex_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_internal_vertex_count" } + } + } + + val getInvert: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "get_invert".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_invert" } + } + } + + val getInvertBorder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "get_invert_border".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_invert_border" } + } + } + + val getOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "get_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_offset" } + } + } + + val getPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "get_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_polygon" } + } + } + + val getPolygons: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "get_polygons".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_polygons" } + } + } + + val getSkeleton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "get_skeleton".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_skeleton" } + } + } + + val getTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "get_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture" } + } + } + + val getTextureOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "get_texture_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture_offset" } + } + } + + val getTextureRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "get_texture_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture_rotation" } + } + } + + val getTextureRotationDegrees: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "get_texture_rotation_degrees".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture_rotation_degrees" } + } + } + + val getTextureScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "get_texture_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture_scale" } + } + } + + val getUv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "get_uv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_uv" } + } + } + + val getVertexColors: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "get_vertex_colors".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vertex_colors" } + } + } + + val setAntialiased: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "set_antialiased".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_antialiased" } + } + } + + val setBonePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "set_bone_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bone_path" } + } + } + + val setBoneWeights: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "set_bone_weights".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bone_weights" } + } + } + + val setColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "set_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_color" } + } + } + + val setInternalVertexCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "set_internal_vertex_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_internal_vertex_count" } + } + } + + val setInvert: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "set_invert".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_invert" } + } + } + + val setInvertBorder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "set_invert_border".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_invert_border" } + } + } + + val setOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "set_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_offset" } + } + } + + val setPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "set_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_polygon" } + } + } + + val setPolygons: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "set_polygons".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_polygons" } + } + } + + val setSkeleton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "set_skeleton".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_skeleton" } + } + } + + val setTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "set_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture" } + } + } + + val setTextureOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "set_texture_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture_offset" } + } + } + + val setTextureRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "set_texture_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture_rotation" } + } + } + + val setTextureRotationDegrees: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "set_texture_rotation_degrees".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture_rotation_degrees" } + } + } + + val setTextureScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "set_texture_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture_scale" } + } + } + + val setUv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "set_uv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_uv" } + } + } + + val setVertexColors: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Polygon2D".cstr.ptr, + "set_vertex_colors".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_vertex_colors" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PolygonPathFinder.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PolygonPathFinder.kt index 8ca7fbec..230b8014 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PolygonPathFinder.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PolygonPathFinder.kt @@ -154,61 +154,77 @@ open class PolygonPathFinder( * Container for method_bind pointers for PolygonPathFinder */ private object __method_bind { - val findPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PolygonPathFinder".cstr.ptr, - "find_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method find_path" } - } - val getBounds: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PolygonPathFinder".cstr.ptr, - "get_bounds".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bounds" } - } - val getClosestPoint: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PolygonPathFinder".cstr.ptr, - "get_closest_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_closest_point" } - } - val getIntersections: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PolygonPathFinder".cstr.ptr, - "get_intersections".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_intersections" } - } - val getPointPenalty: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PolygonPathFinder".cstr.ptr, - "get_point_penalty".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_penalty" } - } - val isPointInside: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PolygonPathFinder".cstr.ptr, - "is_point_inside".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_point_inside" } - } - val setPointPenalty: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PolygonPathFinder".cstr.ptr, - "set_point_penalty".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_penalty" } - } - val setup: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PolygonPathFinder".cstr.ptr, - "setup".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method setup" } - }} + val findPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PolygonPathFinder".cstr.ptr, + "find_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method find_path" } + } + } + + val getBounds: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PolygonPathFinder".cstr.ptr, + "get_bounds".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bounds" } + } + } + + val getClosestPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PolygonPathFinder".cstr.ptr, + "get_closest_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_closest_point" } + } + } + + val getIntersections: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PolygonPathFinder".cstr.ptr, + "get_intersections".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_intersections" } + } + } + + val getPointPenalty: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PolygonPathFinder".cstr.ptr, + "get_point_penalty".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_penalty" } + } + } + + val isPointInside: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PolygonPathFinder".cstr.ptr, + "is_point_inside".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_point_inside" } + } + } + + val setPointPenalty: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PolygonPathFinder".cstr.ptr, + "set_point_penalty".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_penalty" } + } + } + + val setup: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PolygonPathFinder".cstr.ptr, + "setup".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method setup" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Popup.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Popup.kt index f75154df..57412180 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Popup.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Popup.kt @@ -136,53 +136,69 @@ open class Popup( * Container for method_bind pointers for Popup */ private object __method_bind { - val isExclusive: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Popup".cstr.ptr, - "is_exclusive".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_exclusive" } - } - val popup: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Popup".cstr.ptr, - "popup".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method popup" } - } - val popupCentered: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Popup".cstr.ptr, - "popup_centered".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method popup_centered" } - } - val popupCenteredClamped: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Popup".cstr.ptr, - "popup_centered_clamped".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method popup_centered_clamped" } - } - val popupCenteredMinsize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Popup".cstr.ptr, - "popup_centered_minsize".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method popup_centered_minsize" } - } - val popupCenteredRatio: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Popup".cstr.ptr, - "popup_centered_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method popup_centered_ratio" } - } - val setAsMinsize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Popup".cstr.ptr, - "set_as_minsize".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_as_minsize" } - } - val setExclusive: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Popup".cstr.ptr, - "set_exclusive".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_exclusive" } - }} + val isExclusive: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Popup".cstr.ptr, + "is_exclusive".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_exclusive" } + } + } + + val popup: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Popup".cstr.ptr, + "popup".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method popup" } + } + } + + val popupCentered: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Popup".cstr.ptr, + "popup_centered".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method popup_centered" } + } + } + + val popupCenteredClamped: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Popup".cstr.ptr, + "popup_centered_clamped".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method popup_centered_clamped" } + } + } + + val popupCenteredMinsize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Popup".cstr.ptr, + "popup_centered_minsize".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method popup_centered_minsize" } + } + } + + val popupCenteredRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Popup".cstr.ptr, + "popup_centered_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method popup_centered_ratio" } + } + } + + val setAsMinsize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Popup".cstr.ptr, + "set_as_minsize".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_as_minsize" } + } + } + + val setExclusive: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Popup".cstr.ptr, + "set_exclusive".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_exclusive" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PopupMenu.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PopupMenu.kt index 0ee6e260..200f0221 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PopupMenu.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PopupMenu.kt @@ -803,379 +803,569 @@ open class PopupMenu( * Container for method_bind pointers for PopupMenu */ private object __method_bind { - val addCheckItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "add_check_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_check_item" } - } - val addCheckShortcut: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "add_check_shortcut".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_check_shortcut" } - } - val addIconCheckItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "add_icon_check_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_icon_check_item" } - } - val addIconCheckShortcut: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "add_icon_check_shortcut".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_icon_check_shortcut" } - } - val addIconItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "add_icon_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_icon_item" } - } - val addIconRadioCheckItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "add_icon_radio_check_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_icon_radio_check_item" } - } - val addIconRadioCheckShortcut: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "add_icon_radio_check_shortcut".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_icon_radio_check_shortcut" } - } - val addIconShortcut: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "add_icon_shortcut".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_icon_shortcut" } - } - val addItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "add_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_item" } - } - val addMultistateItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "add_multistate_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_multistate_item" } - } - val addRadioCheckItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "add_radio_check_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_radio_check_item" } - } - val addRadioCheckShortcut: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "add_radio_check_shortcut".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_radio_check_shortcut" } - } - val addSeparator: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "add_separator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_separator" } - } - val addShortcut: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "add_shortcut".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_shortcut" } - } - val addSubmenuItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "add_submenu_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_submenu_item" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val getAllowSearch: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "get_allow_search".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_allow_search" } - } - val getItemAccelerator: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "get_item_accelerator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_accelerator" } - } - val getItemCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "get_item_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_count" } - } - val getItemIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "get_item_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_icon" } - } - val getItemId: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "get_item_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_id" } - } - val getItemIndex: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "get_item_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_index" } - } - val getItemMetadata: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "get_item_metadata".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_metadata" } - } - val getItemShortcut: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "get_item_shortcut".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_shortcut" } - } - val getItemSubmenu: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "get_item_submenu".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_submenu" } - } - val getItemText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "get_item_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_text" } - } - val getItemTooltip: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "get_item_tooltip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_tooltip" } - } - val getSubmenuPopupDelay: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "get_submenu_popup_delay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_submenu_popup_delay" } - } - val isHideOnCheckableItemSelection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "is_hide_on_checkable_item_selection".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method is_hide_on_checkable_item_selection" } - } - val isHideOnItemSelection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "is_hide_on_item_selection".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_hide_on_item_selection" } - } - val isHideOnStateItemSelection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "is_hide_on_state_item_selection".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_hide_on_state_item_selection" } - } - val isHideOnWindowLoseFocus: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "is_hide_on_window_lose_focus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_hide_on_window_lose_focus" } - } - val isItemCheckable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "is_item_checkable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_item_checkable" } - } - val isItemChecked: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "is_item_checked".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_item_checked" } - } - val isItemDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "is_item_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_item_disabled" } - } - val isItemRadioCheckable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "is_item_radio_checkable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_item_radio_checkable" } - } - val isItemSeparator: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "is_item_separator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_item_separator" } - } - val isItemShortcutDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "is_item_shortcut_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_item_shortcut_disabled" } - } - val removeItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "remove_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_item" } - } - val setAllowSearch: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_allow_search".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_allow_search" } - } - val setHideOnCheckableItemSelection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_hide_on_checkable_item_selection".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method set_hide_on_checkable_item_selection" } - } - val setHideOnItemSelection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_hide_on_item_selection".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_hide_on_item_selection" } - } - val setHideOnStateItemSelection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_hide_on_state_item_selection".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_hide_on_state_item_selection" } - } - val setHideOnWindowLoseFocus: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_hide_on_window_lose_focus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_hide_on_window_lose_focus" } - } - val setItemAccelerator: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_item_accelerator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_accelerator" } - } - val setItemAsCheckable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_item_as_checkable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_as_checkable" } - } - val setItemAsRadioCheckable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_item_as_radio_checkable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_as_radio_checkable" } - } - val setItemAsSeparator: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_item_as_separator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_as_separator" } - } - val setItemChecked: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_item_checked".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_checked" } - } - val setItemDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_item_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_disabled" } - } - val setItemIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_item_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_icon" } - } - val setItemId: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_item_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_id" } - } - val setItemMetadata: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_item_metadata".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_metadata" } - } - val setItemMultistate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_item_multistate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_multistate" } - } - val setItemShortcut: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_item_shortcut".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_shortcut" } - } - val setItemShortcutDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_item_shortcut_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_shortcut_disabled" } - } - val setItemSubmenu: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_item_submenu".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_submenu" } - } - val setItemText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_item_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_text" } - } - val setItemTooltip: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_item_tooltip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_item_tooltip" } - } - val setSubmenuPopupDelay: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "set_submenu_popup_delay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_submenu_popup_delay" } - } - val toggleItemChecked: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "toggle_item_checked".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method toggle_item_checked" } - } - val toggleItemMultistate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, - "toggle_item_multistate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method toggle_item_multistate" } - }} + val addCheckItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "add_check_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_check_item" } + } + } + + val addCheckShortcut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "add_check_shortcut".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_check_shortcut" } + } + } + + val addIconCheckItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "add_icon_check_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_icon_check_item" } + } + } + + val addIconCheckShortcut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "add_icon_check_shortcut".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_icon_check_shortcut" } + } + } + + val addIconItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "add_icon_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_icon_item" } + } + } + + val addIconRadioCheckItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "add_icon_radio_check_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_icon_radio_check_item" } + } + } + + val addIconRadioCheckShortcut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "add_icon_radio_check_shortcut".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_icon_radio_check_shortcut" + } + } + } + + val addIconShortcut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "add_icon_shortcut".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_icon_shortcut" } + } + } + + val addItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "add_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_item" } + } + } + + val addMultistateItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "add_multistate_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_multistate_item" } + } + } + + val addRadioCheckItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "add_radio_check_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_radio_check_item" } + } + } + + val addRadioCheckShortcut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "add_radio_check_shortcut".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_radio_check_shortcut" } + } + } + + val addSeparator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "add_separator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_separator" } + } + } + + val addShortcut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "add_shortcut".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_shortcut" } + } + } + + val addSubmenuItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "add_submenu_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_submenu_item" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val getAllowSearch: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "get_allow_search".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_allow_search" } + } + } + + val getItemAccelerator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "get_item_accelerator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_accelerator" } + } + } + + val getItemCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "get_item_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_count" } + } + } + + val getItemIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "get_item_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_icon" } + } + } + + val getItemId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "get_item_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_id" } + } + } + + val getItemIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "get_item_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_index" } + } + } + + val getItemMetadata: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "get_item_metadata".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_metadata" } + } + } + + val getItemShortcut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "get_item_shortcut".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_shortcut" } + } + } + + val getItemSubmenu: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "get_item_submenu".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_submenu" } + } + } + + val getItemText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "get_item_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_text" } + } + } + + val getItemTooltip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "get_item_tooltip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_tooltip" } + } + } + + val getSubmenuPopupDelay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "get_submenu_popup_delay".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_submenu_popup_delay" } + } + } + + val isHideOnCheckableItemSelection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "is_hide_on_checkable_item_selection".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_hide_on_checkable_item_selection" } + } + } + + val isHideOnItemSelection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "is_hide_on_item_selection".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_hide_on_item_selection" } + } + } + + val isHideOnStateItemSelection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "is_hide_on_state_item_selection".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_hide_on_state_item_selection" } + } + } + + val isHideOnWindowLoseFocus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "is_hide_on_window_lose_focus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_hide_on_window_lose_focus" } + } + } + + val isItemCheckable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "is_item_checkable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_item_checkable" } + } + } + + val isItemChecked: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "is_item_checked".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_item_checked" } + } + } + + val isItemDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "is_item_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_item_disabled" } + } + } + + val isItemRadioCheckable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "is_item_radio_checkable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_item_radio_checkable" } + } + } + + val isItemSeparator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "is_item_separator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_item_separator" } + } + } + + val isItemShortcutDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "is_item_shortcut_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_item_shortcut_disabled" } + } + } + + val removeItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "remove_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_item" } + } + } + + val setAllowSearch: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_allow_search".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_allow_search" } + } + } + + val setHideOnCheckableItemSelection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_hide_on_checkable_item_selection".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_hide_on_checkable_item_selection" } + } + } + + val setHideOnItemSelection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_hide_on_item_selection".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_hide_on_item_selection" } + } + } + + val setHideOnStateItemSelection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_hide_on_state_item_selection".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_hide_on_state_item_selection" } + } + } + + val setHideOnWindowLoseFocus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_hide_on_window_lose_focus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_hide_on_window_lose_focus" + } + } + } + + val setItemAccelerator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_item_accelerator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_accelerator" } + } + } + + val setItemAsCheckable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_item_as_checkable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_as_checkable" } + } + } + + val setItemAsRadioCheckable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_item_as_radio_checkable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_as_radio_checkable" } + } + } + + val setItemAsSeparator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_item_as_separator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_as_separator" } + } + } + + val setItemChecked: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_item_checked".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_checked" } + } + } + + val setItemDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_item_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_disabled" } + } + } + + val setItemIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_item_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_icon" } + } + } + + val setItemId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_item_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_id" } + } + } + + val setItemMetadata: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_item_metadata".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_metadata" } + } + } + + val setItemMultistate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_item_multistate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_multistate" } + } + } + + val setItemShortcut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_item_shortcut".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_shortcut" } + } + } + + val setItemShortcutDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_item_shortcut_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_shortcut_disabled" } + } + } + + val setItemSubmenu: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_item_submenu".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_submenu" } + } + } + + val setItemText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_item_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_text" } + } + } + + val setItemTooltip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_item_tooltip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_item_tooltip" } + } + } + + val setSubmenuPopupDelay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "set_submenu_popup_delay".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_submenu_popup_delay" } + } + } + + val toggleItemChecked: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "toggle_item_checked".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method toggle_item_checked" } + } + } + + val toggleItemMultistate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PopupMenu".cstr.ptr, + "toggle_item_multistate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method toggle_item_multistate" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PrimitiveMesh.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PrimitiveMesh.kt index 79087395..eafd452b 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PrimitiveMesh.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PrimitiveMesh.kt @@ -146,54 +146,68 @@ open class PrimitiveMesh( * Container for method_bind pointers for PrimitiveMesh */ private object __method_bind { - val getCustomAabb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrimitiveMesh".cstr.ptr, - "get_custom_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_custom_aabb" } - } - val getFlipFaces: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrimitiveMesh".cstr.ptr, - "get_flip_faces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_flip_faces" } - } - val getMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrimitiveMesh".cstr.ptr, - "get_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_material" } - } - val getMeshArrays: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrimitiveMesh".cstr.ptr, - "get_mesh_arrays".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mesh_arrays" } - } - val setCustomAabb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrimitiveMesh".cstr.ptr, - "set_custom_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_custom_aabb" } - } - val setFlipFaces: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrimitiveMesh".cstr.ptr, - "set_flip_faces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flip_faces" } - } - val setMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrimitiveMesh".cstr.ptr, - "set_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_material" } - }} + val getCustomAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrimitiveMesh".cstr.ptr, + "get_custom_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_custom_aabb" } + } + } + + val getFlipFaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrimitiveMesh".cstr.ptr, + "get_flip_faces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_flip_faces" } + } + } + + val getMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrimitiveMesh".cstr.ptr, + "get_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_material" } + } + } + + val getMeshArrays: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrimitiveMesh".cstr.ptr, + "get_mesh_arrays".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mesh_arrays" } + } + } + + val setCustomAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrimitiveMesh".cstr.ptr, + "set_custom_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_custom_aabb" } + } + } + + val setFlipFaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrimitiveMesh".cstr.ptr, + "set_flip_faces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flip_faces" } + } + } + + val setMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrimitiveMesh".cstr.ptr, + "set_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_material" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/PrismMesh.kt b/godot-kotlin/src/nativeGen/kotlin/godot/PrismMesh.kt index 04ceac9b..7af8fe27 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/PrismMesh.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/PrismMesh.kt @@ -186,65 +186,95 @@ open class PrismMesh( * Container for method_bind pointers for PrismMesh */ private object __method_bind { - val getLeftToRight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, - "get_left_to_right".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_left_to_right" } - } - val getSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, - "get_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_size" } - } - val getSubdivideDepth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, - "get_subdivide_depth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_subdivide_depth" } - } - val getSubdivideHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, - "get_subdivide_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_subdivide_height" } - } - val getSubdivideWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, - "get_subdivide_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_subdivide_width" } - } - val setLeftToRight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, - "set_left_to_right".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_left_to_right" } - } - val setSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, - "set_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_size" } - } - val setSubdivideDepth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, - "set_subdivide_depth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_subdivide_depth" } - } - val setSubdivideHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, - "set_subdivide_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_subdivide_height" } - } - val setSubdivideWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, - "set_subdivide_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_subdivide_width" } - }} + val getLeftToRight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, + "get_left_to_right".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_left_to_right" } + } + } + + val getSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, + "get_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_size" } + } + } + + val getSubdivideDepth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, + "get_subdivide_depth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_subdivide_depth" } + } + } + + val getSubdivideHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, + "get_subdivide_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_subdivide_height" } + } + } + + val getSubdivideWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, + "get_subdivide_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_subdivide_width" } + } + } + + val setLeftToRight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, + "set_left_to_right".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_left_to_right" } + } + } + + val setSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, + "set_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_size" } + } + } + + val setSubdivideDepth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, + "set_subdivide_depth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_subdivide_depth" } + } + } + + val setSubdivideHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, + "set_subdivide_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_subdivide_height" } + } + } + + val setSubdivideWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("PrismMesh".cstr.ptr, + "set_subdivide_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_subdivide_width" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ProceduralSky.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ProceduralSky.kt index d5251fef..362902a2 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ProceduralSky.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ProceduralSky.kt @@ -536,229 +536,293 @@ open class ProceduralSky( * Container for method_bind pointers for ProceduralSky */ private object __method_bind { - val getGroundBottomColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "get_ground_bottom_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ground_bottom_color" } - } - val getGroundCurve: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "get_ground_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ground_curve" } - } - val getGroundEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "get_ground_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ground_energy" } - } - val getGroundHorizonColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "get_ground_horizon_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ground_horizon_color" } - } - val getSkyCurve: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "get_sky_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sky_curve" } - } - val getSkyEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "get_sky_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sky_energy" } - } - val getSkyHorizonColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "get_sky_horizon_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sky_horizon_color" } - } - val getSkyTopColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "get_sky_top_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sky_top_color" } - } - val getSunAngleMax: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "get_sun_angle_max".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sun_angle_max" } - } - val getSunAngleMin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "get_sun_angle_min".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sun_angle_min" } - } - val getSunColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "get_sun_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sun_color" } - } - val getSunCurve: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "get_sun_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sun_curve" } - } - val getSunEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "get_sun_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sun_energy" } - } - val getSunLatitude: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "get_sun_latitude".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sun_latitude" } - } - val getSunLongitude: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "get_sun_longitude".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_sun_longitude" } - } - val getTextureSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "get_texture_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture_size" } - } - val setGroundBottomColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "set_ground_bottom_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ground_bottom_color" } - } - val setGroundCurve: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "set_ground_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ground_curve" } - } - val setGroundEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "set_ground_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ground_energy" } - } - val setGroundHorizonColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "set_ground_horizon_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ground_horizon_color" } - } - val setSkyCurve: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "set_sky_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sky_curve" } - } - val setSkyEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "set_sky_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sky_energy" } - } - val setSkyHorizonColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "set_sky_horizon_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sky_horizon_color" } - } - val setSkyTopColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "set_sky_top_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sky_top_color" } - } - val setSunAngleMax: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "set_sun_angle_max".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sun_angle_max" } - } - val setSunAngleMin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "set_sun_angle_min".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sun_angle_min" } - } - val setSunColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "set_sun_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sun_color" } - } - val setSunCurve: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "set_sun_curve".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sun_curve" } - } - val setSunEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "set_sun_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sun_energy" } - } - val setSunLatitude: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "set_sun_latitude".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sun_latitude" } - } - val setSunLongitude: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "set_sun_longitude".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sun_longitude" } - } - val setTextureSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, - "set_texture_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture_size" } - }} + val getGroundBottomColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "get_ground_bottom_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ground_bottom_color" } + } + } + + val getGroundCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "get_ground_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ground_curve" } + } + } + + val getGroundEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "get_ground_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ground_energy" } + } + } + + val getGroundHorizonColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "get_ground_horizon_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ground_horizon_color" } + } + } + + val getSkyCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "get_sky_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sky_curve" } + } + } + + val getSkyEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "get_sky_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sky_energy" } + } + } + + val getSkyHorizonColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "get_sky_horizon_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sky_horizon_color" } + } + } + + val getSkyTopColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "get_sky_top_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sky_top_color" } + } + } + + val getSunAngleMax: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "get_sun_angle_max".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sun_angle_max" } + } + } + + val getSunAngleMin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "get_sun_angle_min".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sun_angle_min" } + } + } + + val getSunColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "get_sun_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sun_color" } + } + } + + val getSunCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "get_sun_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sun_curve" } + } + } + + val getSunEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "get_sun_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sun_energy" } + } + } + + val getSunLatitude: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "get_sun_latitude".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sun_latitude" } + } + } + + val getSunLongitude: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "get_sun_longitude".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_sun_longitude" } + } + } + + val getTextureSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "get_texture_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture_size" } + } + } + + val setGroundBottomColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "set_ground_bottom_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ground_bottom_color" } + } + } + + val setGroundCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "set_ground_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ground_curve" } + } + } + + val setGroundEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "set_ground_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ground_energy" } + } + } + + val setGroundHorizonColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "set_ground_horizon_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ground_horizon_color" } + } + } + + val setSkyCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "set_sky_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sky_curve" } + } + } + + val setSkyEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "set_sky_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sky_energy" } + } + } + + val setSkyHorizonColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "set_sky_horizon_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sky_horizon_color" } + } + } + + val setSkyTopColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "set_sky_top_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sky_top_color" } + } + } + + val setSunAngleMax: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "set_sun_angle_max".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sun_angle_max" } + } + } + + val setSunAngleMin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "set_sun_angle_min".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sun_angle_min" } + } + } + + val setSunColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "set_sun_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sun_color" } + } + } + + val setSunCurve: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "set_sun_curve".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sun_curve" } + } + } + + val setSunEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "set_sun_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sun_energy" } + } + } + + val setSunLatitude: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "set_sun_latitude".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sun_latitude" } + } + } + + val setSunLongitude: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "set_sun_longitude".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sun_longitude" } + } + } + + val setTextureSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProceduralSky".cstr.ptr, + "set_texture_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture_size" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ProgressBar.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ProgressBar.kt index 7374f176..68b211d2 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ProgressBar.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ProgressBar.kt @@ -73,19 +73,23 @@ open class ProgressBar( * Container for method_bind pointers for ProgressBar */ private object __method_bind { - val isPercentVisible: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProgressBar".cstr.ptr, - "is_percent_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_percent_visible" } - } - val setPercentVisible: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProgressBar".cstr.ptr, - "set_percent_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_percent_visible" } - }} + val isPercentVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProgressBar".cstr.ptr, + "is_percent_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_percent_visible" } + } + } + + val setPercentVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProgressBar".cstr.ptr, + "set_percent_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_percent_visible" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ProjectSettings.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ProjectSettings.kt index 04c05827..15bd5a6c 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ProjectSettings.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ProjectSettings.kt @@ -190,111 +190,141 @@ open class ProjectSettingsInternal( * Container for method_bind pointers for ProjectSettings */ private object __method_bind { - val addPropertyInfo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, - "add_property_info".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_property_info" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val getOrder: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, - "get_order".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_order" } - } - val getSetting: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, - "get_setting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_setting" } - } - val globalizePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, - "globalize_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method globalize_path" } - } - val hasSetting: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, - "has_setting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_setting" } - } - val loadResourcePack: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, - "load_resource_pack".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method load_resource_pack" } - } - val localizePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, - "localize_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method localize_path" } - } - val propertyCanRevert: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, - "property_can_revert".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method property_can_revert" } - } - val propertyGetRevert: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, - "property_get_revert".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method property_get_revert" } - } - val save: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, - "save".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method save" } - } - val saveCustom: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, - "save_custom".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method save_custom" } - } - val setInitialValue: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, - "set_initial_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_initial_value" } - } - val setOrder: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, - "set_order".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_order" } - } - val setSetting: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, - "set_setting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_setting" } - }} + val addPropertyInfo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, + "add_property_info".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_property_info" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val getOrder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, + "get_order".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_order" } + } + } + + val getSetting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, + "get_setting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_setting" } + } + } + + val globalizePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, + "globalize_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method globalize_path" } + } + } + + val hasSetting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, + "has_setting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_setting" } + } + } + + val loadResourcePack: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, + "load_resource_pack".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method load_resource_pack" } + } + } + + val localizePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, + "localize_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method localize_path" } + } + } + + val propertyCanRevert: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, + "property_can_revert".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method property_can_revert" } + } + } + + val propertyGetRevert: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, + "property_get_revert".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method property_get_revert" } + } + } + + val save: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, + "save".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method save" } + } + } + + val saveCustom: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, + "save_custom".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method save_custom" } + } + } + + val setInitialValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, + "set_initial_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_initial_value" } + } + } + + val setOrder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, + "set_order".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_order" } + } + } + + val setSetting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProjectSettings".cstr.ptr, + "set_setting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_setting" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ProximityGroup.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ProximityGroup.kt index d63c2e4f..430ff1d9 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ProximityGroup.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ProximityGroup.kt @@ -175,54 +175,68 @@ open class ProximityGroup( * Container for method_bind pointers for ProximityGroup */ private object __method_bind { - val broadcast: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProximityGroup".cstr.ptr, - "broadcast".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method broadcast" } - } - val getDispatchMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProximityGroup".cstr.ptr, - "get_dispatch_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_dispatch_mode" } - } - val getGridRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProximityGroup".cstr.ptr, - "get_grid_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_grid_radius" } - } - val getGroupName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProximityGroup".cstr.ptr, - "get_group_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_group_name" } - } - val setDispatchMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProximityGroup".cstr.ptr, - "set_dispatch_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_dispatch_mode" } - } - val setGridRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProximityGroup".cstr.ptr, - "set_grid_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_grid_radius" } - } - val setGroupName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProximityGroup".cstr.ptr, - "set_group_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_group_name" } - }} + val broadcast: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProximityGroup".cstr.ptr, + "broadcast".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method broadcast" } + } + } + + val getDispatchMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProximityGroup".cstr.ptr, + "get_dispatch_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_dispatch_mode" } + } + } + + val getGridRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProximityGroup".cstr.ptr, + "get_grid_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_grid_radius" } + } + } + + val getGroupName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProximityGroup".cstr.ptr, + "get_group_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_group_name" } + } + } + + val setDispatchMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProximityGroup".cstr.ptr, + "set_dispatch_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_dispatch_mode" } + } + } + + val setGridRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProximityGroup".cstr.ptr, + "set_grid_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_grid_radius" } + } + } + + val setGroupName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProximityGroup".cstr.ptr, + "set_group_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_group_name" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ProxyTexture.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ProxyTexture.kt index 47618b93..e35984ab 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ProxyTexture.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ProxyTexture.kt @@ -74,19 +74,23 @@ open class ProxyTexture( * Container for method_bind pointers for ProxyTexture */ private object __method_bind { - val getBase: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProxyTexture".cstr.ptr, - "get_base".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base" } - } - val setBase: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProxyTexture".cstr.ptr, - "set_base".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_base" } - }} + val getBase: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProxyTexture".cstr.ptr, + "get_base".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base" } + } + } + + val setBase: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ProxyTexture".cstr.ptr, + "set_base".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_base" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/QuadMesh.kt b/godot-kotlin/src/nativeGen/kotlin/godot/QuadMesh.kt index 9bcc2784..3e504334 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/QuadMesh.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/QuadMesh.kt @@ -84,17 +84,23 @@ open class QuadMesh( * Container for method_bind pointers for QuadMesh */ private object __method_bind { - val getSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("QuadMesh".cstr.ptr, - "get_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_size" } - } - val setSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("QuadMesh".cstr.ptr, - "set_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_size" } - }} + val getSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("QuadMesh".cstr.ptr, + "get_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_size" } + } + } + + val setSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("QuadMesh".cstr.ptr, + "set_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_size" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/RandomNumberGenerator.kt b/godot-kotlin/src/nativeGen/kotlin/godot/RandomNumberGenerator.kt index 720f1d5b..f8dfbe8b 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/RandomNumberGenerator.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/RandomNumberGenerator.kt @@ -141,61 +141,77 @@ open class RandomNumberGenerator( * Container for method_bind pointers for RandomNumberGenerator */ private object __method_bind { - val getSeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RandomNumberGenerator".cstr.ptr, - "get_seed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_seed" } - } - val randf: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RandomNumberGenerator".cstr.ptr, - "randf".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method randf" } - } - val randfRange: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RandomNumberGenerator".cstr.ptr, - "randf_range".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method randf_range" } - } - val randfn: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RandomNumberGenerator".cstr.ptr, - "randfn".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method randfn" } - } - val randi: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RandomNumberGenerator".cstr.ptr, - "randi".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method randi" } - } - val randiRange: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RandomNumberGenerator".cstr.ptr, - "randi_range".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method randi_range" } - } - val randomize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RandomNumberGenerator".cstr.ptr, - "randomize".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method randomize" } - } - val setSeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RandomNumberGenerator".cstr.ptr, - "set_seed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_seed" } - }} + val getSeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RandomNumberGenerator".cstr.ptr, + "get_seed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_seed" } + } + } + + val randf: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RandomNumberGenerator".cstr.ptr, + "randf".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method randf" } + } + } + + val randfRange: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RandomNumberGenerator".cstr.ptr, + "randf_range".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method randf_range" } + } + } + + val randfn: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RandomNumberGenerator".cstr.ptr, + "randfn".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method randfn" } + } + } + + val randi: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RandomNumberGenerator".cstr.ptr, + "randi".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method randi" } + } + } + + val randiRange: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RandomNumberGenerator".cstr.ptr, + "randi_range".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method randi_range" } + } + } + + val randomize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RandomNumberGenerator".cstr.ptr, + "randomize".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method randomize" } + } + } + + val setSeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RandomNumberGenerator".cstr.ptr, + "set_seed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_seed" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Range.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Range.kt index 0be13824..5a4b1c58 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Range.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Range.kt @@ -317,137 +317,181 @@ open class Range( * Container for method_bind pointers for Range */ private object __method_bind { - val getAsRatio: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "get_as_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_as_ratio" } - } - val getMax: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "get_max".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_max" } - } - val getMin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "get_min".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_min" } - } - val getPage: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "get_page".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_page" } - } - val getStep: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "get_step".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_step" } - } - val getValue: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "get_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_value" } - } - val isGreaterAllowed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "is_greater_allowed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_greater_allowed" } - } - val isLesserAllowed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "is_lesser_allowed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_lesser_allowed" } - } - val isRatioExp: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "is_ratio_exp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_ratio_exp" } - } - val isUsingRoundedValues: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "is_using_rounded_values".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_using_rounded_values" } - } - val setAllowGreater: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "set_allow_greater".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_allow_greater" } - } - val setAllowLesser: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "set_allow_lesser".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_allow_lesser" } - } - val setAsRatio: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "set_as_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_as_ratio" } - } - val setExpRatio: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "set_exp_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_exp_ratio" } - } - val setMax: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "set_max".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_max" } - } - val setMin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "set_min".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_min" } - } - val setPage: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "set_page".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_page" } - } - val setStep: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "set_step".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_step" } - } - val setUseRoundedValues: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "set_use_rounded_values".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_rounded_values" } - } - val setValue: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "set_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_value" } - } - val share: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "share".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method share" } - } - val unshare: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, - "unshare".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method unshare" } - }} + val getAsRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "get_as_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_as_ratio" } + } + } + + val getMax: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "get_max".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_max" } + } + } + + val getMin: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "get_min".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_min" } + } + } + + val getPage: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "get_page".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_page" } + } + } + + val getStep: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "get_step".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_step" } + } + } + + val getValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "get_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_value" } + } + } + + val isGreaterAllowed: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "is_greater_allowed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_greater_allowed" } + } + } + + val isLesserAllowed: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "is_lesser_allowed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_lesser_allowed" } + } + } + + val isRatioExp: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "is_ratio_exp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_ratio_exp" } + } + } + + val isUsingRoundedValues: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "is_using_rounded_values".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_using_rounded_values" } + } + } + + val setAllowGreater: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "set_allow_greater".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_allow_greater" } + } + } + + val setAllowLesser: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "set_allow_lesser".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_allow_lesser" } + } + } + + val setAsRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "set_as_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_as_ratio" } + } + } + + val setExpRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "set_exp_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_exp_ratio" } + } + } + + val setMax: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "set_max".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_max" } + } + } + + val setMin: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "set_min".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_min" } + } + } + + val setPage: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "set_page".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_page" } + } + } + + val setStep: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "set_step".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_step" } + } + } + + val setUseRoundedValues: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "set_use_rounded_values".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_rounded_values" } + } + } + + val setValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "set_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_value" } + } + } + + val share: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "share".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method share" } + } + } + + val unshare: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Range".cstr.ptr, + "unshare".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method unshare" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/RayCast.kt b/godot-kotlin/src/nativeGen/kotlin/godot/RayCast.kt index 2662651b..831f70bf 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/RayCast.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/RayCast.kt @@ -328,155 +328,232 @@ open class RayCast( * Container for method_bind pointers for RayCast */ private object __method_bind { - val addException: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "add_exception".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_exception" } - } - val addExceptionRid: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "add_exception_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_exception_rid" } - } - val clearExceptions: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "clear_exceptions".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_exceptions" } - } - val forceRaycastUpdate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "force_raycast_update".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method force_raycast_update" } - } - val getCastTo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "get_cast_to".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cast_to" } - } - val getCollider: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "get_collider".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider" } - } - val getColliderShape: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "get_collider_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider_shape" } - } - val getCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "get_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } - } - val getCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "get_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } - } - val getCollisionNormal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "get_collision_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_normal" } - } - val getCollisionPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "get_collision_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_point" } - } - val getExcludeParentBody: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "get_exclude_parent_body".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_exclude_parent_body" } - } - val isCollideWithAreasEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "is_collide_with_areas_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_collide_with_areas_enabled" } - } - val isCollideWithBodiesEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "is_collide_with_bodies_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_collide_with_bodies_enabled" } - } - val isColliding: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "is_colliding".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_colliding" } - } - val isEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "is_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_enabled" } - } - val removeException: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "remove_exception".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_exception" } - } - val removeExceptionRid: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "remove_exception_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_exception_rid" } - } - val setCastTo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "set_cast_to".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cast_to" } - } - val setCollideWithAreas: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "set_collide_with_areas".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collide_with_areas" } - } - val setCollideWithBodies: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "set_collide_with_bodies".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collide_with_bodies" } - } - val setCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "set_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } - } - val setCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "set_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } - } - val setEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "set_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_enabled" } - } - val setExcludeParentBody: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, - "set_exclude_parent_body".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_exclude_parent_body" } - }} + val addException: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "add_exception".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_exception" } + } + } + + val addExceptionRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "add_exception_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_exception_rid" } + } + } + + val clearExceptions: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "clear_exceptions".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_exceptions" } + } + } + + val forceRaycastUpdate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "force_raycast_update".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method force_raycast_update" } + } + } + + val getCastTo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "get_cast_to".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cast_to" } + } + } + + val getCollider: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "get_collider".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider" } + } + } + + val getColliderShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "get_collider_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider_shape" } + } + } + + val getCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "get_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } + } + } + + val getCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "get_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } + } + } + + val getCollisionNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "get_collision_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_normal" } + } + } + + val getCollisionPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "get_collision_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_point" } + } + } + + val getExcludeParentBody: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "get_exclude_parent_body".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_exclude_parent_body" } + } + } + + val isCollideWithAreasEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "is_collide_with_areas_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_collide_with_areas_enabled" + } + } + } + + val isCollideWithBodiesEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "is_collide_with_bodies_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_collide_with_bodies_enabled" + } + } + } + + val isColliding: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "is_colliding".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_colliding" } + } + } + + val isEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "is_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_enabled" } + } + } + + val removeException: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "remove_exception".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_exception" } + } + } + + val removeExceptionRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "remove_exception_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_exception_rid" } + } + } + + val setCastTo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "set_cast_to".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cast_to" } + } + } + + val setCollideWithAreas: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "set_collide_with_areas".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collide_with_areas" } + } + } + + val setCollideWithBodies: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "set_collide_with_bodies".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collide_with_bodies" } + } + } + + val setCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "set_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } + } + } + + val setCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "set_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } + } + } + + val setEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "set_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_enabled" } + } + } + + val setExcludeParentBody: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast".cstr.ptr, + "set_exclude_parent_body".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_exclude_parent_body" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/RayCast2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/RayCast2D.kt index adff6f95..6bdda6aa 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/RayCast2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/RayCast2D.kt @@ -328,155 +328,232 @@ open class RayCast2D( * Container for method_bind pointers for RayCast2D */ private object __method_bind { - val addException: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "add_exception".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_exception" } - } - val addExceptionRid: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "add_exception_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_exception_rid" } - } - val clearExceptions: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "clear_exceptions".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_exceptions" } - } - val forceRaycastUpdate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "force_raycast_update".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method force_raycast_update" } - } - val getCastTo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "get_cast_to".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cast_to" } - } - val getCollider: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "get_collider".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider" } - } - val getColliderShape: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "get_collider_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collider_shape" } - } - val getCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "get_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } - } - val getCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "get_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } - } - val getCollisionNormal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "get_collision_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_normal" } - } - val getCollisionPoint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "get_collision_point".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_point" } - } - val getExcludeParentBody: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "get_exclude_parent_body".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_exclude_parent_body" } - } - val isCollideWithAreasEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "is_collide_with_areas_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_collide_with_areas_enabled" } - } - val isCollideWithBodiesEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "is_collide_with_bodies_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_collide_with_bodies_enabled" } - } - val isColliding: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "is_colliding".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_colliding" } - } - val isEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "is_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_enabled" } - } - val removeException: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "remove_exception".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_exception" } - } - val removeExceptionRid: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "remove_exception_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_exception_rid" } - } - val setCastTo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "set_cast_to".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cast_to" } - } - val setCollideWithAreas: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "set_collide_with_areas".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collide_with_areas" } - } - val setCollideWithBodies: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "set_collide_with_bodies".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collide_with_bodies" } - } - val setCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "set_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } - } - val setCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "set_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } - } - val setEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "set_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_enabled" } - } - val setExcludeParentBody: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, - "set_exclude_parent_body".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_exclude_parent_body" } - }} + val addException: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "add_exception".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_exception" } + } + } + + val addExceptionRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "add_exception_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_exception_rid" } + } + } + + val clearExceptions: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "clear_exceptions".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_exceptions" } + } + } + + val forceRaycastUpdate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "force_raycast_update".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method force_raycast_update" } + } + } + + val getCastTo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "get_cast_to".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cast_to" } + } + } + + val getCollider: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "get_collider".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider" } + } + } + + val getColliderShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "get_collider_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collider_shape" } + } + } + + val getCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "get_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } + } + } + + val getCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "get_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } + } + } + + val getCollisionNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "get_collision_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_normal" } + } + } + + val getCollisionPoint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "get_collision_point".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_point" } + } + } + + val getExcludeParentBody: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "get_exclude_parent_body".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_exclude_parent_body" } + } + } + + val isCollideWithAreasEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "is_collide_with_areas_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_collide_with_areas_enabled" + } + } + } + + val isCollideWithBodiesEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "is_collide_with_bodies_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_collide_with_bodies_enabled" + } + } + } + + val isColliding: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "is_colliding".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_colliding" } + } + } + + val isEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "is_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_enabled" } + } + } + + val removeException: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "remove_exception".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_exception" } + } + } + + val removeExceptionRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "remove_exception_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_exception_rid" } + } + } + + val setCastTo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "set_cast_to".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cast_to" } + } + } + + val setCollideWithAreas: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "set_collide_with_areas".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collide_with_areas" } + } + } + + val setCollideWithBodies: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "set_collide_with_bodies".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collide_with_bodies" } + } + } + + val setCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "set_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } + } + } + + val setCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "set_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } + } + } + + val setEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "set_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_enabled" } + } + } + + val setExcludeParentBody: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayCast2D".cstr.ptr, + "set_exclude_parent_body".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_exclude_parent_body" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/RayShape.kt b/godot-kotlin/src/nativeGen/kotlin/godot/RayShape.kt index 58ec0d0a..62a6ab92 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/RayShape.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/RayShape.kt @@ -99,29 +99,41 @@ open class RayShape( * Container for method_bind pointers for RayShape */ private object __method_bind { - val getLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayShape".cstr.ptr, - "get_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_length" } - } - val getSlipsOnSlope: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayShape".cstr.ptr, - "get_slips_on_slope".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_slips_on_slope" } - } - val setLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayShape".cstr.ptr, - "set_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_length" } - } - val setSlipsOnSlope: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayShape".cstr.ptr, - "set_slips_on_slope".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_slips_on_slope" } - }} + val getLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayShape".cstr.ptr, + "get_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_length" } + } + } + + val getSlipsOnSlope: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayShape".cstr.ptr, + "get_slips_on_slope".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_slips_on_slope" } + } + } + + val setLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayShape".cstr.ptr, + "set_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_length" } + } + } + + val setSlipsOnSlope: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayShape".cstr.ptr, + "set_slips_on_slope".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_slips_on_slope" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/RayShape2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/RayShape2D.kt index 749cbc56..1f883580 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/RayShape2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/RayShape2D.kt @@ -99,29 +99,41 @@ open class RayShape2D( * Container for method_bind pointers for RayShape2D */ private object __method_bind { - val getLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayShape2D".cstr.ptr, - "get_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_length" } - } - val getSlipsOnSlope: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayShape2D".cstr.ptr, - "get_slips_on_slope".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_slips_on_slope" } - } - val setLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayShape2D".cstr.ptr, - "set_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_length" } - } - val setSlipsOnSlope: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayShape2D".cstr.ptr, - "set_slips_on_slope".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_slips_on_slope" } - }} + val getLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayShape2D".cstr.ptr, + "get_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_length" } + } + } + + val getSlipsOnSlope: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayShape2D".cstr.ptr, + "get_slips_on_slope".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_slips_on_slope" } + } + } + + val setLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayShape2D".cstr.ptr, + "set_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_length" } + } + } + + val setSlipsOnSlope: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RayShape2D".cstr.ptr, + "set_slips_on_slope".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_slips_on_slope" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/RectangleShape2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/RectangleShape2D.kt index 2656fdef..41eac85e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/RectangleShape2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/RectangleShape2D.kt @@ -85,19 +85,23 @@ open class RectangleShape2D( * Container for method_bind pointers for RectangleShape2D */ private object __method_bind { - val getExtents: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RectangleShape2D".cstr.ptr, - "get_extents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_extents" } - } - val setExtents: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RectangleShape2D".cstr.ptr, - "set_extents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_extents" } - }} + val getExtents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RectangleShape2D".cstr.ptr, + "get_extents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_extents" } + } + } + + val setExtents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RectangleShape2D".cstr.ptr, + "set_extents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_extents" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Reference.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Reference.kt index 951865ac..bc97b5ea 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Reference.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Reference.kt @@ -78,23 +78,32 @@ open class Reference( * Container for method_bind pointers for Reference */ private object __method_bind { - val initRef: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Reference".cstr.ptr, - "init_ref".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method init_ref" } - } - val reference: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Reference".cstr.ptr, - "reference".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method reference" } - } - val unreference: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Reference".cstr.ptr, - "unreference".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method unreference" } - }} + val initRef: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Reference".cstr.ptr, + "init_ref".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method init_ref" } + } + } + + val reference: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Reference".cstr.ptr, + "reference".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method reference" } + } + } + + val unreference: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Reference".cstr.ptr, + "unreference".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method unreference" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ReferenceRect.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ReferenceRect.kt index f566681f..016f2656 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ReferenceRect.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ReferenceRect.kt @@ -110,33 +110,41 @@ open class ReferenceRect( * Container for method_bind pointers for ReferenceRect */ private object __method_bind { - val getBorderColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReferenceRect".cstr.ptr, - "get_border_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_border_color" } - } - val getEditorOnly: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReferenceRect".cstr.ptr, - "get_editor_only".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_editor_only" } - } - val setBorderColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReferenceRect".cstr.ptr, - "set_border_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_border_color" } - } - val setEditorOnly: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReferenceRect".cstr.ptr, - "set_editor_only".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_editor_only" } - }} + val getBorderColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReferenceRect".cstr.ptr, + "get_border_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_border_color" } + } + } + + val getEditorOnly: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReferenceRect".cstr.ptr, + "get_editor_only".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_editor_only" } + } + } + + val setBorderColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReferenceRect".cstr.ptr, + "set_border_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_border_color" } + } + } + + val setEditorOnly: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReferenceRect".cstr.ptr, + "set_editor_only".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_editor_only" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ReflectionProbe.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ReflectionProbe.kt index 4507e038..c99d505e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ReflectionProbe.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ReflectionProbe.kt @@ -404,175 +404,223 @@ open class ReflectionProbe( * Container for method_bind pointers for ReflectionProbe */ private object __method_bind { - val areShadowsEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "are_shadows_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method are_shadows_enabled" } - } - val getCullMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "get_cull_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cull_mask" } - } - val getExtents: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "get_extents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_extents" } - } - val getIntensity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "get_intensity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_intensity" } - } - val getInteriorAmbient: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "get_interior_ambient".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_interior_ambient" } - } - val getInteriorAmbientEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "get_interior_ambient_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_interior_ambient_energy" } - } - val getInteriorAmbientProbeContribution: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "get_interior_ambient_probe_contribution".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method get_interior_ambient_probe_contribution" } - } - val getMaxDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "get_max_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_max_distance" } - } - val getOriginOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "get_origin_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_origin_offset" } - } - val getUpdateMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "get_update_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_update_mode" } - } - val isBoxProjectionEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "is_box_projection_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_box_projection_enabled" } - } - val isSetAsInterior: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "is_set_as_interior".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_set_as_interior" } - } - val setAsInterior: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "set_as_interior".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_as_interior" } - } - val setCullMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "set_cull_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cull_mask" } - } - val setEnableBoxProjection: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "set_enable_box_projection".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_enable_box_projection" } - } - val setEnableShadows: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "set_enable_shadows".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_enable_shadows" } - } - val setExtents: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "set_extents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_extents" } - } - val setIntensity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "set_intensity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_intensity" } - } - val setInteriorAmbient: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "set_interior_ambient".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_interior_ambient" } - } - val setInteriorAmbientEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "set_interior_ambient_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_interior_ambient_energy" } - } - val setInteriorAmbientProbeContribution: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "set_interior_ambient_probe_contribution".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method set_interior_ambient_probe_contribution" } - } - val setMaxDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "set_max_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_max_distance" } - } - val setOriginOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "set_origin_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_origin_offset" } - } - val setUpdateMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, - "set_update_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_update_mode" } - }} + val areShadowsEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "are_shadows_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method are_shadows_enabled" } + } + } + + val getCullMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "get_cull_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cull_mask" } + } + } + + val getExtents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "get_extents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_extents" } + } + } + + val getIntensity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "get_intensity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_intensity" } + } + } + + val getInteriorAmbient: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "get_interior_ambient".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_interior_ambient" } + } + } + + val getInteriorAmbientEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "get_interior_ambient_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_interior_ambient_energy" } + } + } + + val getInteriorAmbientProbeContribution: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "get_interior_ambient_probe_contribution".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_interior_ambient_probe_contribution" } + } + } + + val getMaxDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "get_max_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_max_distance" } + } + } + + val getOriginOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "get_origin_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_origin_offset" } + } + } + + val getUpdateMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "get_update_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_update_mode" } + } + } + + val isBoxProjectionEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "is_box_projection_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_box_projection_enabled" } + } + } + + val isSetAsInterior: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "is_set_as_interior".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_set_as_interior" } + } + } + + val setAsInterior: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "set_as_interior".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_as_interior" } + } + } + + val setCullMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "set_cull_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cull_mask" } + } + } + + val setEnableBoxProjection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "set_enable_box_projection".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_enable_box_projection" } + } + } + + val setEnableShadows: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "set_enable_shadows".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_enable_shadows" } + } + } + + val setExtents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "set_extents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_extents" } + } + } + + val setIntensity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "set_intensity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_intensity" } + } + } + + val setInteriorAmbient: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "set_interior_ambient".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_interior_ambient" } + } + } + + val setInteriorAmbientEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "set_interior_ambient_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_interior_ambient_energy" } + } + } + + val setInteriorAmbientProbeContribution: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "set_interior_ambient_probe_contribution".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_interior_ambient_probe_contribution" } + } + } + + val setMaxDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "set_max_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_max_distance" } + } + } + + val setOriginOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "set_origin_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_origin_offset" } + } + } + + val setUpdateMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ReflectionProbe".cstr.ptr, + "set_update_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_update_mode" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/RegEx.kt b/godot-kotlin/src/nativeGen/kotlin/godot/RegEx.kt index 233713fd..a7ae42ca 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/RegEx.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/RegEx.kt @@ -171,59 +171,77 @@ open class RegEx( * Container for method_bind pointers for RegEx */ private object __method_bind { - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegEx".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val compile: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegEx".cstr.ptr, - "compile".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method compile" } - } - val getGroupCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegEx".cstr.ptr, - "get_group_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_group_count" } - } - val getNames: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegEx".cstr.ptr, - "get_names".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_names" } - } - val getPattern: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegEx".cstr.ptr, - "get_pattern".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pattern" } - } - val isValid: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegEx".cstr.ptr, - "is_valid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_valid" } - } - val search: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegEx".cstr.ptr, - "search".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method search" } - } - val searchAll: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegEx".cstr.ptr, - "search_all".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method search_all" } - } - val sub: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegEx".cstr.ptr, - "sub".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method sub" } - }} + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegEx".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val compile: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegEx".cstr.ptr, + "compile".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method compile" } + } + } + + val getGroupCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegEx".cstr.ptr, + "get_group_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_group_count" } + } + } + + val getNames: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegEx".cstr.ptr, + "get_names".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_names" } + } + } + + val getPattern: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegEx".cstr.ptr, + "get_pattern".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pattern" } + } + } + + val isValid: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegEx".cstr.ptr, + "is_valid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_valid" } + } + } + + val search: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegEx".cstr.ptr, + "search".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method search" } + } + } + + val searchAll: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegEx".cstr.ptr, + "search_all".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method search_all" } + } + } + + val sub: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegEx".cstr.ptr, + "sub".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method sub" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/RegExMatch.kt b/godot-kotlin/src/nativeGen/kotlin/godot/RegExMatch.kt index e37efc65..943b5f36 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/RegExMatch.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/RegExMatch.kt @@ -138,47 +138,68 @@ open class RegExMatch( * Container for method_bind pointers for RegExMatch */ private object __method_bind { - val getEnd: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegExMatch".cstr.ptr, - "get_end".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_end" } - } - val getGroupCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegExMatch".cstr.ptr, - "get_group_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_group_count" } - } - val getNames: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegExMatch".cstr.ptr, - "get_names".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_names" } - } - val getStart: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegExMatch".cstr.ptr, - "get_start".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_start" } - } - val getString: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegExMatch".cstr.ptr, - "get_string".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_string" } - } - val getStrings: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegExMatch".cstr.ptr, - "get_strings".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_strings" } - } - val getSubject: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegExMatch".cstr.ptr, - "get_subject".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_subject" } - }} + val getEnd: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegExMatch".cstr.ptr, + "get_end".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_end" } + } + } + + val getGroupCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegExMatch".cstr.ptr, + "get_group_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_group_count" } + } + } + + val getNames: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegExMatch".cstr.ptr, + "get_names".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_names" } + } + } + + val getStart: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegExMatch".cstr.ptr, + "get_start".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_start" } + } + } + + val getString: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegExMatch".cstr.ptr, + "get_string".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_string" } + } + } + + val getStrings: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegExMatch".cstr.ptr, + "get_strings".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_strings" } + } + } + + val getSubject: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RegExMatch".cstr.ptr, + "get_subject".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_subject" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/RemoteTransform.kt b/godot-kotlin/src/nativeGen/kotlin/godot/RemoteTransform.kt index d13dd6b9..bcc8e935 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/RemoteTransform.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/RemoteTransform.kt @@ -193,82 +193,104 @@ open class RemoteTransform( * Container for method_bind pointers for RemoteTransform */ private object __method_bind { - val forceUpdateCache: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, - "force_update_cache".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method force_update_cache" } - } - val getRemoteNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, - "get_remote_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_remote_node" } - } - val getUpdatePosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, - "get_update_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_update_position" } - } - val getUpdateRotation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, - "get_update_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_update_rotation" } - } - val getUpdateScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, - "get_update_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_update_scale" } - } - val getUseGlobalCoordinates: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, - "get_use_global_coordinates".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_use_global_coordinates" } - } - val setRemoteNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, - "set_remote_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_remote_node" } - } - val setUpdatePosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, - "set_update_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_update_position" } - } - val setUpdateRotation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, - "set_update_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_update_rotation" } - } - val setUpdateScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, - "set_update_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_update_scale" } - } - val setUseGlobalCoordinates: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, - "set_use_global_coordinates".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_global_coordinates" } - }} + val forceUpdateCache: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, + "force_update_cache".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method force_update_cache" } + } + } + + val getRemoteNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, + "get_remote_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_remote_node" } + } + } + + val getUpdatePosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, + "get_update_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_update_position" } + } + } + + val getUpdateRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, + "get_update_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_update_rotation" } + } + } + + val getUpdateScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, + "get_update_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_update_scale" } + } + } + + val getUseGlobalCoordinates: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, + "get_use_global_coordinates".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_use_global_coordinates" } + } + } + + val setRemoteNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, + "set_remote_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_remote_node" } + } + } + + val setUpdatePosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, + "set_update_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_update_position" } + } + } + + val setUpdateRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, + "set_update_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_update_rotation" } + } + } + + val setUpdateScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, + "set_update_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_update_scale" } + } + } + + val setUseGlobalCoordinates: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform".cstr.ptr, + "set_use_global_coordinates".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_global_coordinates" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/RemoteTransform2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/RemoteTransform2D.kt index d7bc966a..000bbf95 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/RemoteTransform2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/RemoteTransform2D.kt @@ -193,82 +193,104 @@ open class RemoteTransform2D( * Container for method_bind pointers for RemoteTransform2D */ private object __method_bind { - val forceUpdateCache: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, - "force_update_cache".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method force_update_cache" } - } - val getRemoteNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, - "get_remote_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_remote_node" } - } - val getUpdatePosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, - "get_update_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_update_position" } - } - val getUpdateRotation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, - "get_update_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_update_rotation" } - } - val getUpdateScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, - "get_update_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_update_scale" } - } - val getUseGlobalCoordinates: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, - "get_use_global_coordinates".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_use_global_coordinates" } - } - val setRemoteNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, - "set_remote_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_remote_node" } - } - val setUpdatePosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, - "set_update_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_update_position" } - } - val setUpdateRotation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, - "set_update_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_update_rotation" } - } - val setUpdateScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, - "set_update_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_update_scale" } - } - val setUseGlobalCoordinates: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, - "set_use_global_coordinates".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_global_coordinates" } - }} + val forceUpdateCache: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, + "force_update_cache".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method force_update_cache" } + } + } + + val getRemoteNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, + "get_remote_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_remote_node" } + } + } + + val getUpdatePosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, + "get_update_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_update_position" } + } + } + + val getUpdateRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, + "get_update_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_update_rotation" } + } + } + + val getUpdateScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, + "get_update_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_update_scale" } + } + } + + val getUseGlobalCoordinates: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, + "get_use_global_coordinates".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_use_global_coordinates" } + } + } + + val setRemoteNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, + "set_remote_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_remote_node" } + } + } + + val setUpdatePosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, + "set_update_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_update_position" } + } + } + + val setUpdateRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, + "set_update_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_update_rotation" } + } + } + + val setUpdateScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, + "set_update_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_update_scale" } + } + } + + val setUseGlobalCoordinates: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RemoteTransform2D".cstr.ptr, + "set_use_global_coordinates".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_global_coordinates" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Resource.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Resource.kt index a58703c6..9860e4c0 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Resource.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Resource.kt @@ -184,71 +184,104 @@ open class Resource( * Container for method_bind pointers for Resource */ private object __method_bind { - val duplicate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, - "duplicate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method duplicate" } - } - val getLocalScene: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, - "get_local_scene".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_local_scene" } - } - val getName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, - "get_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_name" } - } - val getPath: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, - "get_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_path" } - } - val getRid: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, - "get_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rid" } - } - val isLocalToScene: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, - "is_local_to_scene".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_local_to_scene" } - } - val setLocalToScene: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, - "set_local_to_scene".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_local_to_scene" } - } - val setName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, - "set_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_name" } - } - val setPath: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, - "set_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_path" } - } - val setupLocalToScene: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, - "setup_local_to_scene".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method setup_local_to_scene" } - } - val takeOverPath: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, - "take_over_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method take_over_path" } - }} + val duplicate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, + "duplicate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method duplicate" } + } + } + + val getLocalScene: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, + "get_local_scene".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_local_scene" } + } + } + + val getName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, + "get_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_name" } + } + } + + val getPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, + "get_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_path" } + } + } + + val getRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, + "get_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rid" } + } + } + + val isLocalToScene: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, + "is_local_to_scene".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_local_to_scene" } + } + } + + val setLocalToScene: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, + "set_local_to_scene".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_local_to_scene" } + } + } + + val setName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, + "set_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_name" } + } + } + + val setPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, + "set_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_path" } + } + } + + val setupLocalToScene: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, + "setup_local_to_scene".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method setup_local_to_scene" } + } + } + + val takeOverPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Resource".cstr.ptr, + "take_over_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method take_over_path" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ResourceInteractiveLoader.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ResourceInteractiveLoader.kt index a6e01450..6060c1bc 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ResourceInteractiveLoader.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ResourceInteractiveLoader.kt @@ -95,40 +95,50 @@ open class ResourceInteractiveLoader( * Container for method_bind pointers for ResourceInteractiveLoader */ private object __method_bind { - val getResource: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourceInteractiveLoader".cstr.ptr, - "get_resource".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_resource" } - } - val getStage: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourceInteractiveLoader".cstr.ptr, - "get_stage".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stage" } - } - val getStageCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourceInteractiveLoader".cstr.ptr, - "get_stage_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stage_count" } - } - val poll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourceInteractiveLoader".cstr.ptr, - "poll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method poll" } - } - val wait: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourceInteractiveLoader".cstr.ptr, - "wait".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method wait" } - }} + val getResource: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourceInteractiveLoader".cstr.ptr, + "get_resource".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_resource" } + } + } + + val getStage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourceInteractiveLoader".cstr.ptr, + "get_stage".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stage" } + } + } + + val getStageCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourceInteractiveLoader".cstr.ptr, + "get_stage_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stage_count" } + } + } + + val poll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourceInteractiveLoader".cstr.ptr, + "poll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method poll" } + } + } + + val wait: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourceInteractiveLoader".cstr.ptr, + "wait".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method wait" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ResourceLoader.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ResourceLoader.kt index 24efdaac..707106e7 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ResourceLoader.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ResourceLoader.kt @@ -134,63 +134,80 @@ open class ResourceLoaderInternal( * Container for method_bind pointers for ResourceLoader */ private object __method_bind { - val exists: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceLoader".cstr.ptr, - "exists".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method exists" } - } - val getDependencies: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceLoader".cstr.ptr, - "get_dependencies".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_dependencies" } - } - val getRecognizedExtensionsForType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceLoader".cstr.ptr, - "get_recognized_extensions_for_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_recognized_extensions_for_type" + val exists: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceLoader".cstr.ptr, + "exists".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method exists" } } - } - val has: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceLoader".cstr.ptr, - "has".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has" } - } - val hasCached: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceLoader".cstr.ptr, - "has_cached".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_cached" } - } - val load: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceLoader".cstr.ptr, - "load".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method load" } - } - val loadInteractive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceLoader".cstr.ptr, - "load_interactive".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method load_interactive" } - } - val setAbortOnMissingResources: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceLoader".cstr.ptr, - "set_abort_on_missing_resources".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_abort_on_missing_resources" } - }} + } + + val getDependencies: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceLoader".cstr.ptr, + "get_dependencies".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_dependencies" } + } + } + + val getRecognizedExtensionsForType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceLoader".cstr.ptr, + "get_recognized_extensions_for_type".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_recognized_extensions_for_type" } + } + } + + val has: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceLoader".cstr.ptr, + "has".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has" } + } + } + + val hasCached: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceLoader".cstr.ptr, + "has_cached".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_cached" } + } + } + + val load: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceLoader".cstr.ptr, + "load".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method load" } + } + } + + val loadInteractive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceLoader".cstr.ptr, + "load_interactive".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method load_interactive" } + } + } + + val setAbortOnMissingResources: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceLoader".cstr.ptr, + "set_abort_on_missing_resources".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_abort_on_missing_resources" + } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ResourcePreloader.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ResourcePreloader.kt index 9e5b02d0..3480ceee 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ResourcePreloader.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ResourcePreloader.kt @@ -118,47 +118,59 @@ open class ResourcePreloader( * Container for method_bind pointers for ResourcePreloader */ private object __method_bind { - val addResource: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourcePreloader".cstr.ptr, - "add_resource".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_resource" } - } - val getResource: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourcePreloader".cstr.ptr, - "get_resource".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_resource" } - } - val getResourceList: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourcePreloader".cstr.ptr, - "get_resource_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_resource_list" } - } - val hasResource: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourcePreloader".cstr.ptr, - "has_resource".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_resource" } - } - val removeResource: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourcePreloader".cstr.ptr, - "remove_resource".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_resource" } - } - val renameResource: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourcePreloader".cstr.ptr, - "rename_resource".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rename_resource" } - }} + val addResource: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourcePreloader".cstr.ptr, + "add_resource".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_resource" } + } + } + + val getResource: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourcePreloader".cstr.ptr, + "get_resource".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_resource" } + } + } + + val getResourceList: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourcePreloader".cstr.ptr, + "get_resource_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_resource_list" } + } + } + + val hasResource: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourcePreloader".cstr.ptr, + "has_resource".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_resource" } + } + } + + val removeResource: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourcePreloader".cstr.ptr, + "remove_resource".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_resource" } + } + } + + val renameResource: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ResourcePreloader".cstr.ptr, + "rename_resource".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rename_resource" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ResourceSaver.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ResourceSaver.kt index 2d173dea..83d6aeac 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ResourceSaver.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ResourceSaver.kt @@ -67,20 +67,24 @@ open class ResourceSaverInternal( * Container for method_bind pointers for ResourceSaver */ private object __method_bind { - val getRecognizedExtensions: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceSaver".cstr.ptr, - "get_recognized_extensions".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_recognized_extensions" } - } - val save: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceSaver".cstr.ptr, - "save".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method save" } - }} + val getRecognizedExtensions: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceSaver".cstr.ptr, + "get_recognized_extensions".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_recognized_extensions" } + } + } + + val save: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_ResourceSaver".cstr.ptr, + "save".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method save" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/RichTextLabel.kt b/godot-kotlin/src/nativeGen/kotlin/godot/RichTextLabel.kt index 1538d713..eea9ffde 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/RichTextLabel.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/RichTextLabel.kt @@ -743,398 +743,511 @@ open class RichTextLabel( * Container for method_bind pointers for RichTextLabel */ private object __method_bind { - val addImage: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "add_image".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_image" } - } - val addText: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "add_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_text" } - } - val appendBbcode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "append_bbcode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method append_bbcode" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val getBbcode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "get_bbcode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bbcode" } - } - val getContentHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "get_content_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_content_height" } - } - val getEffects: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "get_effects".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_effects" } - } - val getLineCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "get_line_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_line_count" } - } - val getPercentVisible: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "get_percent_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_percent_visible" } - } - val getTabSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "get_tab_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tab_size" } - } - val getText: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "get_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_text" } - } - val getTotalCharacterCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "get_total_character_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_total_character_count" } - } - val getVScroll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "get_v_scroll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_v_scroll" } - } - val getVisibleCharacters: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "get_visible_characters".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_visible_characters" } - } - val getVisibleLineCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "get_visible_line_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_visible_line_count" } - } - val installEffect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "install_effect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method install_effect" } - } - val isMetaUnderlined: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "is_meta_underlined".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_meta_underlined" } - } - val isOverridingSelectedFontColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "is_overriding_selected_font_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_overriding_selected_font_color" + val addImage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "add_image".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_image" } } - } - val isScrollActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "is_scroll_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_scroll_active" } - } - val isScrollFollowing: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "is_scroll_following".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_scroll_following" } - } - val isSelectionEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "is_selection_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_selection_enabled" } - } - val isUsingBbcode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "is_using_bbcode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_using_bbcode" } - } - val newline: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "newline".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method newline" } - } - val parseBbcode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "parse_bbcode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method parse_bbcode" } - } - val parseExpressionsForValues: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "parse_expressions_for_values".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method parse_expressions_for_values" } - } - val pop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "pop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method pop" } - } - val pushAlign: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "push_align".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method push_align" } - } - val pushBold: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "push_bold".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method push_bold" } - } - val pushBoldItalics: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "push_bold_italics".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method push_bold_italics" } - } - val pushCell: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "push_cell".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method push_cell" } - } - val pushColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "push_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method push_color" } - } - val pushFont: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "push_font".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method push_font" } - } - val pushIndent: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "push_indent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method push_indent" } - } - val pushItalics: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "push_italics".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method push_italics" } - } - val pushList: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "push_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method push_list" } - } - val pushMeta: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "push_meta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method push_meta" } - } - val pushMono: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "push_mono".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method push_mono" } - } - val pushNormal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "push_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method push_normal" } - } - val pushStrikethrough: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "push_strikethrough".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method push_strikethrough" } - } - val pushTable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "push_table".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method push_table" } - } - val pushUnderline: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "push_underline".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method push_underline" } - } - val removeLine: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "remove_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_line" } - } - val scrollToLine: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "scroll_to_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method scroll_to_line" } - } - val setBbcode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "set_bbcode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bbcode" } - } - val setEffects: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "set_effects".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_effects" } - } - val setMetaUnderline: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "set_meta_underline".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_meta_underline" } - } - val setOverrideSelectedFontColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "set_override_selected_font_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_override_selected_font_color" } - } - val setPercentVisible: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "set_percent_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_percent_visible" } - } - val setScrollActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "set_scroll_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_scroll_active" } - } - val setScrollFollow: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "set_scroll_follow".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_scroll_follow" } - } - val setSelectionEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "set_selection_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_selection_enabled" } - } - val setTabSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "set_tab_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tab_size" } - } - val setTableColumnExpand: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "set_table_column_expand".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_table_column_expand" } - } - val setText: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "set_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_text" } - } - val setUseBbcode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "set_use_bbcode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_bbcode" } - } - val setVisibleCharacters: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, - "set_visible_characters".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_visible_characters" } - }} + } + + val addText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "add_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_text" } + } + } + + val appendBbcode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "append_bbcode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method append_bbcode" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val getBbcode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "get_bbcode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bbcode" } + } + } + + val getContentHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "get_content_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_content_height" } + } + } + + val getEffects: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "get_effects".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_effects" } + } + } + + val getLineCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "get_line_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_line_count" } + } + } + + val getPercentVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "get_percent_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_percent_visible" } + } + } + + val getTabSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "get_tab_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tab_size" } + } + } + + val getText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "get_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_text" } + } + } + + val getTotalCharacterCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "get_total_character_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_total_character_count" } + } + } + + val getVScroll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "get_v_scroll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_v_scroll" } + } + } + + val getVisibleCharacters: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "get_visible_characters".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_visible_characters" } + } + } + + val getVisibleLineCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "get_visible_line_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_visible_line_count" } + } + } + + val installEffect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "install_effect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method install_effect" } + } + } + + val isMetaUnderlined: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "is_meta_underlined".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_meta_underlined" } + } + } + + val isOverridingSelectedFontColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "is_overriding_selected_font_color".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_overriding_selected_font_color" } + } + } + + val isScrollActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "is_scroll_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_scroll_active" } + } + } + + val isScrollFollowing: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "is_scroll_following".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_scroll_following" } + } + } + + val isSelectionEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "is_selection_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_selection_enabled" } + } + } + + val isUsingBbcode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "is_using_bbcode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_using_bbcode" } + } + } + + val newline: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "newline".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method newline" } + } + } + + val parseBbcode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "parse_bbcode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method parse_bbcode" } + } + } + + val parseExpressionsForValues: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "parse_expressions_for_values".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method parse_expressions_for_values" } + } + } + + val pop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "pop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method pop" } + } + } + + val pushAlign: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "push_align".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method push_align" } + } + } + + val pushBold: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "push_bold".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method push_bold" } + } + } + + val pushBoldItalics: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "push_bold_italics".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method push_bold_italics" } + } + } + + val pushCell: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "push_cell".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method push_cell" } + } + } + + val pushColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "push_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method push_color" } + } + } + + val pushFont: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "push_font".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method push_font" } + } + } + + val pushIndent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "push_indent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method push_indent" } + } + } + + val pushItalics: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "push_italics".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method push_italics" } + } + } + + val pushList: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "push_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method push_list" } + } + } + + val pushMeta: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "push_meta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method push_meta" } + } + } + + val pushMono: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "push_mono".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method push_mono" } + } + } + + val pushNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "push_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method push_normal" } + } + } + + val pushStrikethrough: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "push_strikethrough".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method push_strikethrough" } + } + } + + val pushTable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "push_table".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method push_table" } + } + } + + val pushUnderline: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "push_underline".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method push_underline" } + } + } + + val removeLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "remove_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_line" } + } + } + + val scrollToLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "scroll_to_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method scroll_to_line" } + } + } + + val setBbcode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "set_bbcode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bbcode" } + } + } + + val setEffects: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "set_effects".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_effects" } + } + } + + val setMetaUnderline: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "set_meta_underline".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_meta_underline" } + } + } + + val setOverrideSelectedFontColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "set_override_selected_font_color".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_override_selected_font_color" } + } + } + + val setPercentVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "set_percent_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_percent_visible" } + } + } + + val setScrollActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "set_scroll_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_scroll_active" } + } + } + + val setScrollFollow: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "set_scroll_follow".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_scroll_follow" } + } + } + + val setSelectionEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "set_selection_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_selection_enabled" } + } + } + + val setTabSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "set_tab_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tab_size" } + } + } + + val setTableColumnExpand: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "set_table_column_expand".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_table_column_expand" } + } + } + + val setText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "set_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_text" } + } + } + + val setUseBbcode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "set_use_bbcode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_bbcode" } + } + } + + val setVisibleCharacters: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RichTextLabel".cstr.ptr, + "set_visible_characters".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_visible_characters" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/RigidBody.kt b/godot-kotlin/src/nativeGen/kotlin/godot/RigidBody.kt index f3d73b4a..353cf2c1 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/RigidBody.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/RigidBody.kt @@ -702,271 +702,405 @@ open class RigidBody( * Container for method_bind pointers for RigidBody */ private object __method_bind { - val addCentralForce: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "add_central_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_central_force" } - } - val addForce: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "add_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_force" } - } - val addTorque: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "add_torque".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_torque" } - } - val applyCentralImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "apply_central_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method apply_central_impulse" } - } - val applyImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "apply_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method apply_impulse" } - } - val applyTorqueImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "apply_torque_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method apply_torque_impulse" } - } - val getAngularDamp: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "get_angular_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_angular_damp" } - } - val getAngularVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "get_angular_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_angular_velocity" } - } - val getAxisLock: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "get_axis_lock".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_axis_lock" } - } - val getBounce: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "get_bounce".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bounce" } - } - val getCollidingBodies: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "get_colliding_bodies".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_colliding_bodies" } - } - val getFriction: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "get_friction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_friction" } - } - val getGravityScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "get_gravity_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gravity_scale" } - } - val getLinearDamp: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "get_linear_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_linear_damp" } - } - val getLinearVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "get_linear_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_linear_velocity" } - } - val getMass: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "get_mass".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mass" } - } - val getMaxContactsReported: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "get_max_contacts_reported".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_max_contacts_reported" } - } - val getMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "get_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mode" } - } - val getPhysicsMaterialOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "get_physics_material_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_physics_material_override" } - } - val getWeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "get_weight".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_weight" } - } - val isAbleToSleep: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "is_able_to_sleep".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_able_to_sleep" } - } - val isContactMonitorEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "is_contact_monitor_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_contact_monitor_enabled" } - } - val isSleeping: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "is_sleeping".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_sleeping" } - } - val isUsingContinuousCollisionDetection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "is_using_continuous_collision_detection".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method is_using_continuous_collision_detection" } - } - val isUsingCustomIntegrator: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "is_using_custom_integrator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_using_custom_integrator" } - } - val setAngularDamp: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "set_angular_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_angular_damp" } - } - val setAngularVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "set_angular_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_angular_velocity" } - } - val setAxisLock: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "set_axis_lock".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_axis_lock" } - } - val setAxisVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "set_axis_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_axis_velocity" } - } - val setBounce: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "set_bounce".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bounce" } - } - val setCanSleep: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "set_can_sleep".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_can_sleep" } - } - val setContactMonitor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "set_contact_monitor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_contact_monitor" } - } - val setFriction: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "set_friction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_friction" } - } - val setGravityScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "set_gravity_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_gravity_scale" } - } - val setLinearDamp: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "set_linear_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_linear_damp" } - } - val setLinearVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "set_linear_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_linear_velocity" } - } - val setMass: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "set_mass".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mass" } - } - val setMaxContactsReported: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "set_max_contacts_reported".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_max_contacts_reported" } - } - val setMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "set_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mode" } - } - val setPhysicsMaterialOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "set_physics_material_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_physics_material_override" } - } - val setSleeping: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "set_sleeping".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sleeping" } - } - val setUseContinuousCollisionDetection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "set_use_continuous_collision_detection".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method set_use_continuous_collision_detection" } - } - val setUseCustomIntegrator: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "set_use_custom_integrator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_custom_integrator" } - } - val setWeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, - "set_weight".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_weight" } - }} + val addCentralForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "add_central_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_central_force" } + } + } + + val addForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "add_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_force" } + } + } + + val addTorque: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "add_torque".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_torque" } + } + } + + val applyCentralImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "apply_central_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method apply_central_impulse" } + } + } + + val applyImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "apply_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method apply_impulse" } + } + } + + val applyTorqueImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "apply_torque_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method apply_torque_impulse" } + } + } + + val getAngularDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "get_angular_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_angular_damp" } + } + } + + val getAngularVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "get_angular_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_angular_velocity" } + } + } + + val getAxisLock: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "get_axis_lock".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_axis_lock" } + } + } + + val getBounce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "get_bounce".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bounce" } + } + } + + val getCollidingBodies: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "get_colliding_bodies".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_colliding_bodies" } + } + } + + val getFriction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "get_friction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_friction" } + } + } + + val getGravityScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "get_gravity_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gravity_scale" } + } + } + + val getLinearDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "get_linear_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_linear_damp" } + } + } + + val getLinearVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "get_linear_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_linear_velocity" } + } + } + + val getMass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "get_mass".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mass" } + } + } + + val getMaxContactsReported: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "get_max_contacts_reported".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_max_contacts_reported" } + } + } + + val getMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "get_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mode" } + } + } + + val getPhysicsMaterialOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "get_physics_material_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_physics_material_override" + } + } + } + + val getWeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "get_weight".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_weight" } + } + } + + val isAbleToSleep: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "is_able_to_sleep".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_able_to_sleep" } + } + } + + val isContactMonitorEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "is_contact_monitor_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_contact_monitor_enabled" } + } + } + + val isSleeping: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "is_sleeping".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_sleeping" } + } + } + + val isUsingContinuousCollisionDetection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "is_using_continuous_collision_detection".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_using_continuous_collision_detection" } + } + } + + val isUsingCustomIntegrator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "is_using_custom_integrator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_using_custom_integrator" } + } + } + + val setAngularDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "set_angular_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_angular_damp" } + } + } + + val setAngularVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "set_angular_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_angular_velocity" } + } + } + + val setAxisLock: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "set_axis_lock".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_axis_lock" } + } + } + + val setAxisVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "set_axis_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_axis_velocity" } + } + } + + val setBounce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "set_bounce".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bounce" } + } + } + + val setCanSleep: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "set_can_sleep".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_can_sleep" } + } + } + + val setContactMonitor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "set_contact_monitor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_contact_monitor" } + } + } + + val setFriction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "set_friction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_friction" } + } + } + + val setGravityScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "set_gravity_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_gravity_scale" } + } + } + + val setLinearDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "set_linear_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_linear_damp" } + } + } + + val setLinearVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "set_linear_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_linear_velocity" } + } + } + + val setMass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "set_mass".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mass" } + } + } + + val setMaxContactsReported: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "set_max_contacts_reported".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_max_contacts_reported" } + } + } + + val setMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "set_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mode" } + } + } + + val setPhysicsMaterialOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "set_physics_material_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_physics_material_override" + } + } + } + + val setSleeping: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "set_sleeping".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sleeping" } + } + } + + val setUseContinuousCollisionDetection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "set_use_continuous_collision_detection".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_use_continuous_collision_detection" } + } + } + + val setUseCustomIntegrator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "set_use_custom_integrator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_custom_integrator" } + } + } + + val setWeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody".cstr.ptr, + "set_weight".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_weight" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/RigidBody2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/RigidBody2D.kt index f2af274a..f67d50a4 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/RigidBody2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/RigidBody2D.kt @@ -750,350 +750,450 @@ open class RigidBody2D( * Container for method_bind pointers for RigidBody2D */ private object __method_bind { - val addCentralForce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "add_central_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_central_force" } - } - val addForce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "add_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_force" } - } - val addTorque: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "add_torque".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_torque" } - } - val applyCentralImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "apply_central_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method apply_central_impulse" } - } - val applyImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "apply_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method apply_impulse" } - } - val applyTorqueImpulse: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "apply_torque_impulse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method apply_torque_impulse" } - } - val getAngularDamp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "get_angular_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_angular_damp" } - } - val getAngularVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "get_angular_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_angular_velocity" } - } - val getAppliedForce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "get_applied_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_applied_force" } - } - val getAppliedTorque: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "get_applied_torque".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_applied_torque" } - } - val getBounce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "get_bounce".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bounce" } - } - val getCollidingBodies: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "get_colliding_bodies".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_colliding_bodies" } - } - val getContinuousCollisionDetectionMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "get_continuous_collision_detection_mode".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method get_continuous_collision_detection_mode" } - } - val getFriction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "get_friction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_friction" } - } - val getGravityScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "get_gravity_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gravity_scale" } - } - val getInertia: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "get_inertia".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_inertia" } - } - val getLinearDamp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "get_linear_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_linear_damp" } - } - val getLinearVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "get_linear_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_linear_velocity" } - } - val getMass: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "get_mass".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mass" } - } - val getMaxContactsReported: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "get_max_contacts_reported".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_max_contacts_reported" } - } - val getMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "get_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mode" } - } - val getPhysicsMaterialOverride: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "get_physics_material_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_physics_material_override" } - } - val getWeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "get_weight".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_weight" } - } - val isAbleToSleep: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "is_able_to_sleep".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_able_to_sleep" } - } - val isContactMonitorEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "is_contact_monitor_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_contact_monitor_enabled" } - } - val isSleeping: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "is_sleeping".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_sleeping" } - } - val isUsingCustomIntegrator: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "is_using_custom_integrator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_using_custom_integrator" } - } - val setAngularDamp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_angular_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_angular_damp" } - } - val setAngularVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_angular_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_angular_velocity" } - } - val setAppliedForce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_applied_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_applied_force" } - } - val setAppliedTorque: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_applied_torque".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_applied_torque" } - } - val setAxisVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_axis_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_axis_velocity" } - } - val setBounce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_bounce".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bounce" } - } - val setCanSleep: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_can_sleep".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_can_sleep" } - } - val setContactMonitor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_contact_monitor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_contact_monitor" } - } - val setContinuousCollisionDetectionMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_continuous_collision_detection_mode".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method set_continuous_collision_detection_mode" } - } - val setFriction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_friction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_friction" } - } - val setGravityScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_gravity_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_gravity_scale" } - } - val setInertia: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_inertia".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_inertia" } - } - val setLinearDamp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_linear_damp".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_linear_damp" } - } - val setLinearVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_linear_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_linear_velocity" } - } - val setMass: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_mass".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mass" } - } - val setMaxContactsReported: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_max_contacts_reported".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_max_contacts_reported" } - } - val setMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mode" } - } - val setPhysicsMaterialOverride: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_physics_material_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_physics_material_override" } - } - val setSleeping: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_sleeping".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sleeping" } - } - val setUseCustomIntegrator: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_use_custom_integrator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_custom_integrator" } - } - val setWeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "set_weight".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_weight" } - } - val testMotion: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, - "test_motion".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method test_motion" } - }} + val addCentralForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "add_central_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_central_force" } + } + } + + val addForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "add_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_force" } + } + } + + val addTorque: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "add_torque".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_torque" } + } + } + + val applyCentralImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "apply_central_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method apply_central_impulse" } + } + } + + val applyImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "apply_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method apply_impulse" } + } + } + + val applyTorqueImpulse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "apply_torque_impulse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method apply_torque_impulse" } + } + } + + val getAngularDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "get_angular_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_angular_damp" } + } + } + + val getAngularVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "get_angular_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_angular_velocity" } + } + } + + val getAppliedForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "get_applied_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_applied_force" } + } + } + + val getAppliedTorque: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "get_applied_torque".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_applied_torque" } + } + } + + val getBounce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "get_bounce".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bounce" } + } + } + + val getCollidingBodies: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "get_colliding_bodies".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_colliding_bodies" } + } + } + + val getContinuousCollisionDetectionMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "get_continuous_collision_detection_mode".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_continuous_collision_detection_mode" } + } + } + + val getFriction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "get_friction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_friction" } + } + } + + val getGravityScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "get_gravity_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gravity_scale" } + } + } + + val getInertia: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "get_inertia".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_inertia" } + } + } + + val getLinearDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "get_linear_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_linear_damp" } + } + } + + val getLinearVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "get_linear_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_linear_velocity" } + } + } + + val getMass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "get_mass".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mass" } + } + } + + val getMaxContactsReported: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "get_max_contacts_reported".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_max_contacts_reported" } + } + } + + val getMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "get_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mode" } + } + } + + val getPhysicsMaterialOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "get_physics_material_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_physics_material_override" + } + } + } + + val getWeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "get_weight".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_weight" } + } + } + + val isAbleToSleep: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "is_able_to_sleep".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_able_to_sleep" } + } + } + + val isContactMonitorEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "is_contact_monitor_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_contact_monitor_enabled" } + } + } + + val isSleeping: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "is_sleeping".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_sleeping" } + } + } + + val isUsingCustomIntegrator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "is_using_custom_integrator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_using_custom_integrator" } + } + } + + val setAngularDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_angular_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_angular_damp" } + } + } + + val setAngularVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_angular_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_angular_velocity" } + } + } + + val setAppliedForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_applied_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_applied_force" } + } + } + + val setAppliedTorque: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_applied_torque".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_applied_torque" } + } + } + + val setAxisVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_axis_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_axis_velocity" } + } + } + + val setBounce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_bounce".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bounce" } + } + } + + val setCanSleep: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_can_sleep".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_can_sleep" } + } + } + + val setContactMonitor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_contact_monitor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_contact_monitor" } + } + } + + val setContinuousCollisionDetectionMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_continuous_collision_detection_mode".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_continuous_collision_detection_mode" } + } + } + + val setFriction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_friction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_friction" } + } + } + + val setGravityScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_gravity_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_gravity_scale" } + } + } + + val setInertia: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_inertia".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_inertia" } + } + } + + val setLinearDamp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_linear_damp".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_linear_damp" } + } + } + + val setLinearVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_linear_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_linear_velocity" } + } + } + + val setMass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_mass".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mass" } + } + } + + val setMaxContactsReported: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_max_contacts_reported".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_max_contacts_reported" } + } + } + + val setMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mode" } + } + } + + val setPhysicsMaterialOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_physics_material_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_physics_material_override" + } + } + } + + val setSleeping: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_sleeping".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sleeping" } + } + } + + val setUseCustomIntegrator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_use_custom_integrator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_custom_integrator" } + } + } + + val setWeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "set_weight".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_weight" } + } + } + + val testMotion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("RigidBody2D".cstr.ptr, + "test_motion".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method test_motion" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/SceneState.kt b/godot-kotlin/src/nativeGen/kotlin/godot/SceneState.kt index 7ac41cb6..18deafa4 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/SceneState.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/SceneState.kt @@ -290,125 +290,186 @@ open class SceneState( * Container for method_bind pointers for SceneState */ private object __method_bind { - val getConnectionBinds: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "get_connection_binds".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connection_binds" } - } - val getConnectionCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "get_connection_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connection_count" } - } - val getConnectionFlags: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "get_connection_flags".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connection_flags" } - } - val getConnectionMethod: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "get_connection_method".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connection_method" } - } - val getConnectionSignal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "get_connection_signal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connection_signal" } - } - val getConnectionSource: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "get_connection_source".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connection_source" } - } - val getConnectionTarget: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "get_connection_target".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connection_target" } - } - val getNodeCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "get_node_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_count" } - } - val getNodeGroups: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "get_node_groups".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_groups" } - } - val getNodeIndex: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "get_node_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_index" } - } - val getNodeInstance: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "get_node_instance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_instance" } - } - val getNodeInstancePlaceholder: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "get_node_instance_placeholder".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_instance_placeholder" } - } - val getNodeName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "get_node_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_name" } - } - val getNodeOwnerPath: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "get_node_owner_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_owner_path" } - } - val getNodePath: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "get_node_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_path" } - } - val getNodePropertyCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "get_node_property_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_property_count" } - } - val getNodePropertyName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "get_node_property_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_property_name" } - } - val getNodePropertyValue: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "get_node_property_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_property_value" } - } - val getNodeType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "get_node_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_type" } - } - val isNodeInstancePlaceholder: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, - "is_node_instance_placeholder".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_node_instance_placeholder" } - }} + val getConnectionBinds: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "get_connection_binds".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connection_binds" } + } + } + + val getConnectionCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "get_connection_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connection_count" } + } + } + + val getConnectionFlags: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "get_connection_flags".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connection_flags" } + } + } + + val getConnectionMethod: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "get_connection_method".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connection_method" } + } + } + + val getConnectionSignal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "get_connection_signal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connection_signal" } + } + } + + val getConnectionSource: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "get_connection_source".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connection_source" } + } + } + + val getConnectionTarget: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "get_connection_target".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connection_target" } + } + } + + val getNodeCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "get_node_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_count" } + } + } + + val getNodeGroups: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "get_node_groups".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_groups" } + } + } + + val getNodeIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "get_node_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_index" } + } + } + + val getNodeInstance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "get_node_instance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_instance" } + } + } + + val getNodeInstancePlaceholder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "get_node_instance_placeholder".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_instance_placeholder" + } + } + } + + val getNodeName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "get_node_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_name" } + } + } + + val getNodeOwnerPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "get_node_owner_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_owner_path" } + } + } + + val getNodePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "get_node_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_path" } + } + } + + val getNodePropertyCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "get_node_property_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_property_count" } + } + } + + val getNodePropertyName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "get_node_property_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_property_name" } + } + } + + val getNodePropertyValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "get_node_property_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_property_value" } + } + } + + val getNodeType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "get_node_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_type" } + } + } + + val isNodeInstancePlaceholder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneState".cstr.ptr, + "is_node_instance_placeholder".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_node_instance_placeholder" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/SceneTree.kt b/godot-kotlin/src/nativeGen/kotlin/godot/SceneTree.kt index f56e07a6..5770db0b 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/SceneTree.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/SceneTree.kt @@ -783,289 +783,430 @@ open class SceneTree( * Container for method_bind pointers for SceneTree */ private object __method_bind { - val callGroup: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "call_group".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method call_group" } - } - val callGroupFlags: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "call_group_flags".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method call_group_flags" } - } - val changeScene: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "change_scene".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method change_scene" } - } - val changeSceneTo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "change_scene_to".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method change_scene_to" } - } - val createTimer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "create_timer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_timer" } - } - val getCurrentScene: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "get_current_scene".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_scene" } - } - val getEditedSceneRoot: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "get_edited_scene_root".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_edited_scene_root" } - } - val getFrame: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "get_frame".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_frame" } - } - val getMultiplayer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "get_multiplayer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_multiplayer" } - } - val getNetworkConnectedPeers: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "get_network_connected_peers".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_network_connected_peers" } - } - val getNetworkPeer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "get_network_peer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_network_peer" } - } - val getNetworkUniqueId: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "get_network_unique_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_network_unique_id" } - } - val getNodeCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "get_node_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_count" } - } - val getNodesInGroup: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "get_nodes_in_group".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_nodes_in_group" } - } - val getRoot: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "get_root".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_root" } - } - val getRpcSenderId: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "get_rpc_sender_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rpc_sender_id" } - } - val hasGroup: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "has_group".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_group" } - } - val hasNetworkPeer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "has_network_peer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_network_peer" } - } - val isDebuggingCollisionsHint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "is_debugging_collisions_hint".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_debugging_collisions_hint" } - } - val isDebuggingNavigationHint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "is_debugging_navigation_hint".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_debugging_navigation_hint" } - } - val isInputHandled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "is_input_handled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_input_handled" } - } - val isMultiplayerPollEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "is_multiplayer_poll_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_multiplayer_poll_enabled" } - } - val isNetworkServer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "is_network_server".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_network_server" } - } - val isPaused: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "is_paused".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_paused" } - } - val isRefusingNewNetworkConnections: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "is_refusing_new_network_connections".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method is_refusing_new_network_connections" } - } - val isUsingFontOversampling: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "is_using_font_oversampling".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_using_font_oversampling" } - } - val notifyGroup: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "notify_group".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method notify_group" } - } - val notifyGroupFlags: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "notify_group_flags".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method notify_group_flags" } - } - val queueDelete: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "queue_delete".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method queue_delete" } - } - val quit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "quit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method quit" } - } - val reloadCurrentScene: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "reload_current_scene".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method reload_current_scene" } - } - val setAutoAcceptQuit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "set_auto_accept_quit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_auto_accept_quit" } - } - val setCurrentScene: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "set_current_scene".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_current_scene" } - } - val setDebugCollisionsHint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "set_debug_collisions_hint".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_debug_collisions_hint" } - } - val setDebugNavigationHint: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "set_debug_navigation_hint".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_debug_navigation_hint" } - } - val setEditedSceneRoot: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "set_edited_scene_root".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_edited_scene_root" } - } - val setGroup: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "set_group".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_group" } - } - val setGroupFlags: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "set_group_flags".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_group_flags" } - } - val setInputAsHandled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "set_input_as_handled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_input_as_handled" } - } - val setMultiplayer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "set_multiplayer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_multiplayer" } - } - val setMultiplayerPollEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "set_multiplayer_poll_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_multiplayer_poll_enabled" } - } - val setNetworkPeer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "set_network_peer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_network_peer" } - } - val setPause: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "set_pause".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pause" } - } - val setQuitOnGoBack: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "set_quit_on_go_back".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_quit_on_go_back" } - } - val setRefuseNewNetworkConnections: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "set_refuse_new_network_connections".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_refuse_new_network_connections" + val callGroup: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "call_group".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method call_group" } } - } - val setScreenStretch: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "set_screen_stretch".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_screen_stretch" } - } - val setUseFontOversampling: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, - "set_use_font_oversampling".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_font_oversampling" } - }} + } + + val callGroupFlags: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "call_group_flags".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method call_group_flags" } + } + } + + val changeScene: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "change_scene".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method change_scene" } + } + } + + val changeSceneTo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "change_scene_to".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method change_scene_to" } + } + } + + val createTimer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "create_timer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_timer" } + } + } + + val getCurrentScene: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "get_current_scene".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_scene" } + } + } + + val getEditedSceneRoot: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "get_edited_scene_root".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_edited_scene_root" } + } + } + + val getFrame: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "get_frame".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_frame" } + } + } + + val getMultiplayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "get_multiplayer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_multiplayer" } + } + } + + val getNetworkConnectedPeers: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "get_network_connected_peers".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_network_connected_peers" } + } + } + + val getNetworkPeer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "get_network_peer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_network_peer" } + } + } + + val getNetworkUniqueId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "get_network_unique_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_network_unique_id" } + } + } + + val getNodeCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "get_node_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_count" } + } + } + + val getNodesInGroup: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "get_nodes_in_group".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_nodes_in_group" } + } + } + + val getRoot: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "get_root".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_root" } + } + } + + val getRpcSenderId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "get_rpc_sender_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rpc_sender_id" } + } + } + + val hasGroup: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "has_group".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_group" } + } + } + + val hasNetworkPeer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "has_network_peer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_network_peer" } + } + } + + val isDebuggingCollisionsHint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "is_debugging_collisions_hint".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_debugging_collisions_hint" } + } + } + + val isDebuggingNavigationHint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "is_debugging_navigation_hint".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_debugging_navigation_hint" } + } + } + + val isInputHandled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "is_input_handled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_input_handled" } + } + } + + val isMultiplayerPollEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "is_multiplayer_poll_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_multiplayer_poll_enabled" } + } + } + + val isNetworkServer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "is_network_server".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_network_server" } + } + } + + val isPaused: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "is_paused".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_paused" } + } + } + + val isRefusingNewNetworkConnections: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "is_refusing_new_network_connections".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_refusing_new_network_connections" } + } + } + + val isUsingFontOversampling: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "is_using_font_oversampling".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_using_font_oversampling" } + } + } + + val notifyGroup: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "notify_group".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method notify_group" } + } + } + + val notifyGroupFlags: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "notify_group_flags".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method notify_group_flags" } + } + } + + val queueDelete: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "queue_delete".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method queue_delete" } + } + } + + val quit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "quit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method quit" } + } + } + + val reloadCurrentScene: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "reload_current_scene".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method reload_current_scene" } + } + } + + val setAutoAcceptQuit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "set_auto_accept_quit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_auto_accept_quit" } + } + } + + val setCurrentScene: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "set_current_scene".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_current_scene" } + } + } + + val setDebugCollisionsHint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "set_debug_collisions_hint".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_debug_collisions_hint" } + } + } + + val setDebugNavigationHint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "set_debug_navigation_hint".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_debug_navigation_hint" } + } + } + + val setEditedSceneRoot: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "set_edited_scene_root".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_edited_scene_root" } + } + } + + val setGroup: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "set_group".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_group" } + } + } + + val setGroupFlags: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "set_group_flags".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_group_flags" } + } + } + + val setInputAsHandled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "set_input_as_handled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_input_as_handled" } + } + } + + val setMultiplayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "set_multiplayer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_multiplayer" } + } + } + + val setMultiplayerPollEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "set_multiplayer_poll_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_multiplayer_poll_enabled" } + } + } + + val setNetworkPeer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "set_network_peer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_network_peer" } + } + } + + val setPause: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "set_pause".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pause" } + } + } + + val setQuitOnGoBack: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "set_quit_on_go_back".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_quit_on_go_back" } + } + } + + val setRefuseNewNetworkConnections: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "set_refuse_new_network_connections".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_refuse_new_network_connections" } + } + } + + val setScreenStretch: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "set_screen_stretch".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_screen_stretch" } + } + } + + val setUseFontOversampling: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTree".cstr.ptr, + "set_use_font_oversampling".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_font_oversampling" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/SceneTreeTimer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/SceneTreeTimer.kt index 4aefdf83..2045de16 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/SceneTreeTimer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/SceneTreeTimer.kt @@ -72,19 +72,23 @@ open class SceneTreeTimer( * Container for method_bind pointers for SceneTreeTimer */ private object __method_bind { - val getTimeLeft: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTreeTimer".cstr.ptr, - "get_time_left".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_time_left" } - } - val setTimeLeft: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTreeTimer".cstr.ptr, - "set_time_left".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_time_left" } - }} + val getTimeLeft: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTreeTimer".cstr.ptr, + "get_time_left".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_time_left" } + } + } + + val setTimeLeft: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SceneTreeTimer".cstr.ptr, + "set_time_left".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_time_left" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Script.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Script.kt index 4ae35681..87cfddfe 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Script.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Script.kt @@ -208,95 +208,125 @@ open class Script( * Container for method_bind pointers for Script */ private object __method_bind { - val canInstance: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, - "can_instance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method can_instance" } - } - val getBaseScript: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, - "get_base_script".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base_script" } - } - val getInstanceBaseType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, - "get_instance_base_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_instance_base_type" } - } - val getPropertyDefaultValue: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, - "get_property_default_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_property_default_value" } - } - val getScriptConstantMap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, - "get_script_constant_map".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_script_constant_map" } - } - val getScriptMethodList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, - "get_script_method_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_script_method_list" } - } - val getScriptPropertyList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, - "get_script_property_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_script_property_list" } - } - val getScriptSignalList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, - "get_script_signal_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_script_signal_list" } - } - val getSourceCode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, - "get_source_code".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_source_code" } - } - val hasScriptSignal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, - "has_script_signal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_script_signal" } - } - val hasSourceCode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, - "has_source_code".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_source_code" } - } - val instanceHas: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, - "instance_has".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instance_has" } - } - val isTool: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, - "is_tool".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_tool" } - } - val reload: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, - "reload".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method reload" } - } - val setSourceCode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, - "set_source_code".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_source_code" } - }} + val canInstance: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, + "can_instance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method can_instance" } + } + } + + val getBaseScript: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, + "get_base_script".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base_script" } + } + } + + val getInstanceBaseType: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, + "get_instance_base_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_instance_base_type" } + } + } + + val getPropertyDefaultValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, + "get_property_default_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_property_default_value" } + } + } + + val getScriptConstantMap: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, + "get_script_constant_map".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_script_constant_map" } + } + } + + val getScriptMethodList: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, + "get_script_method_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_script_method_list" } + } + } + + val getScriptPropertyList: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, + "get_script_property_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_script_property_list" } + } + } + + val getScriptSignalList: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, + "get_script_signal_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_script_signal_list" } + } + } + + val getSourceCode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, + "get_source_code".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_source_code" } + } + } + + val hasScriptSignal: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, + "has_script_signal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_script_signal" } + } + } + + val hasSourceCode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, + "has_source_code".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_source_code" } + } + } + + val instanceHas: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, + "instance_has".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method instance_has" } + } + } + + val isTool: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, + "is_tool".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_tool" } + } + } + + val reload: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, + "reload".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method reload" } + } + } + + val setSourceCode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Script".cstr.ptr, + "set_source_code".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_source_code" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ScriptCreateDialog.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ScriptCreateDialog.kt index 537d304b..9842ec09 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ScriptCreateDialog.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ScriptCreateDialog.kt @@ -113,12 +113,14 @@ open class ScriptCreateDialog( * Container for method_bind pointers for ScriptCreateDialog */ private object __method_bind { - val config: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScriptCreateDialog".cstr.ptr, - "config".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method config" } - }} + val config: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScriptCreateDialog".cstr.ptr, + "config".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method config" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ScriptEditor.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ScriptEditor.kt index da567a99..14518313 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ScriptEditor.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ScriptEditor.kt @@ -372,54 +372,68 @@ open class ScriptEditor( * Container for method_bind pointers for ScriptEditor */ private object __method_bind { - val canDropDataFw: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScriptEditor".cstr.ptr, - "can_drop_data_fw".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method can_drop_data_fw" } - } - val dropDataFw: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScriptEditor".cstr.ptr, - "drop_data_fw".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method drop_data_fw" } - } - val getCurrentScript: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScriptEditor".cstr.ptr, - "get_current_script".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_script" } - } - val getDragDataFw: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScriptEditor".cstr.ptr, - "get_drag_data_fw".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_drag_data_fw" } - } - val getOpenScripts: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScriptEditor".cstr.ptr, - "get_open_scripts".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_open_scripts" } - } - val gotoLine: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScriptEditor".cstr.ptr, - "goto_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method goto_line" } - } - val openScriptCreateDialog: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScriptEditor".cstr.ptr, - "open_script_create_dialog".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method open_script_create_dialog" } - }} + val canDropDataFw: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScriptEditor".cstr.ptr, + "can_drop_data_fw".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method can_drop_data_fw" } + } + } + + val dropDataFw: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScriptEditor".cstr.ptr, + "drop_data_fw".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method drop_data_fw" } + } + } + + val getCurrentScript: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScriptEditor".cstr.ptr, + "get_current_script".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_script" } + } + } + + val getDragDataFw: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScriptEditor".cstr.ptr, + "get_drag_data_fw".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_drag_data_fw" } + } + } + + val getOpenScripts: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScriptEditor".cstr.ptr, + "get_open_scripts".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_open_scripts" } + } + } + + val gotoLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScriptEditor".cstr.ptr, + "goto_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method goto_line" } + } + } + + val openScriptCreateDialog: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScriptEditor".cstr.ptr, + "open_script_create_dialog".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method open_script_create_dialog" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ScrollBar.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ScrollBar.kt index 17fb202f..d1ede8e8 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ScrollBar.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ScrollBar.kt @@ -80,17 +80,23 @@ open class ScrollBar( * Container for method_bind pointers for ScrollBar */ private object __method_bind { - val getCustomStep: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollBar".cstr.ptr, - "get_custom_step".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_custom_step" } - } - val setCustomStep: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollBar".cstr.ptr, - "set_custom_step".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_custom_step" } - }} + val getCustomStep: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollBar".cstr.ptr, + "get_custom_step".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_custom_step" } + } + } + + val setCustomStep: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollBar".cstr.ptr, + "set_custom_step".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_custom_step" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ScrollContainer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ScrollContainer.kt index ecf5a069..c2e0fd0a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ScrollContainer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ScrollContainer.kt @@ -247,103 +247,131 @@ open class ScrollContainer( * Container for method_bind pointers for ScrollContainer */ private object __method_bind { - val getDeadzone: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, - "get_deadzone".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_deadzone" } - } - val getHScroll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, - "get_h_scroll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_h_scroll" } - } - val getHScrollbar: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, - "get_h_scrollbar".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_h_scrollbar" } - } - val getVScroll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, - "get_v_scroll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_v_scroll" } - } - val getVScrollbar: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, - "get_v_scrollbar".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_v_scrollbar" } - } - val isFollowingFocus: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, - "is_following_focus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_following_focus" } - } - val isHScrollEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, - "is_h_scroll_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_h_scroll_enabled" } - } - val isVScrollEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, - "is_v_scroll_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_v_scroll_enabled" } - } - val setDeadzone: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, - "set_deadzone".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_deadzone" } - } - val setEnableHScroll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, - "set_enable_h_scroll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_enable_h_scroll" } - } - val setEnableVScroll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, - "set_enable_v_scroll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_enable_v_scroll" } - } - val setFollowFocus: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, - "set_follow_focus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_follow_focus" } - } - val setHScroll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, - "set_h_scroll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_h_scroll" } - } - val setVScroll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, - "set_v_scroll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_v_scroll" } - }} + val getDeadzone: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, + "get_deadzone".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_deadzone" } + } + } + + val getHScroll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, + "get_h_scroll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_h_scroll" } + } + } + + val getHScrollbar: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, + "get_h_scrollbar".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_h_scrollbar" } + } + } + + val getVScroll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, + "get_v_scroll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_v_scroll" } + } + } + + val getVScrollbar: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, + "get_v_scrollbar".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_v_scrollbar" } + } + } + + val isFollowingFocus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, + "is_following_focus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_following_focus" } + } + } + + val isHScrollEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, + "is_h_scroll_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_h_scroll_enabled" } + } + } + + val isVScrollEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, + "is_v_scroll_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_v_scroll_enabled" } + } + } + + val setDeadzone: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, + "set_deadzone".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_deadzone" } + } + } + + val setEnableHScroll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, + "set_enable_h_scroll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_enable_h_scroll" } + } + } + + val setEnableVScroll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, + "set_enable_v_scroll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_enable_v_scroll" } + } + } + + val setFollowFocus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, + "set_follow_focus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_follow_focus" } + } + } + + val setHScroll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, + "set_h_scroll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_h_scroll" } + } + } + + val setVScroll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ScrollContainer".cstr.ptr, + "set_v_scroll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_v_scroll" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/SegmentShape2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/SegmentShape2D.kt index a9366787..fe88698c 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/SegmentShape2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/SegmentShape2D.kt @@ -120,33 +120,41 @@ open class SegmentShape2D( * Container for method_bind pointers for SegmentShape2D */ private object __method_bind { - val getA: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SegmentShape2D".cstr.ptr, - "get_a".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_a" } - } - val getB: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SegmentShape2D".cstr.ptr, - "get_b".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_b" } - } - val setA: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SegmentShape2D".cstr.ptr, - "set_a".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_a" } - } - val setB: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SegmentShape2D".cstr.ptr, - "set_b".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_b" } - }} + val getA: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SegmentShape2D".cstr.ptr, + "get_a".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_a" } + } + } + + val getB: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SegmentShape2D".cstr.ptr, + "get_b".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_b" } + } + } + + val setA: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SegmentShape2D".cstr.ptr, + "set_a".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_a" } + } + } + + val setB: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SegmentShape2D".cstr.ptr, + "set_b".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_b" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Semaphore.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Semaphore.kt index 96f98e02..285dac6a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Semaphore.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Semaphore.kt @@ -68,17 +68,23 @@ open class Semaphore( * Container for method_bind pointers for Semaphore */ private object __method_bind { - val post: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Semaphore".cstr.ptr, - "post".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method post" } - } - val wait: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Semaphore".cstr.ptr, - "wait".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method wait" } - }} + val post: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Semaphore".cstr.ptr, + "post".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method post" } + } + } + + val wait: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Semaphore".cstr.ptr, + "wait".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method wait" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Shader.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Shader.kt index 4a5bf550..7ae12133 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Shader.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Shader.kt @@ -138,41 +138,53 @@ open class Shader( * Container for method_bind pointers for Shader */ private object __method_bind { - val getCode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shader".cstr.ptr, - "get_code".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_code" } - } - val getDefaultTextureParam: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shader".cstr.ptr, - "get_default_texture_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_default_texture_param" } - } - val getMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shader".cstr.ptr, - "get_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mode" } - } - val hasParam: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shader".cstr.ptr, - "has_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_param" } - } - val setCode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shader".cstr.ptr, - "set_code".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_code" } - } - val setDefaultTextureParam: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shader".cstr.ptr, - "set_default_texture_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_default_texture_param" } - }} + val getCode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shader".cstr.ptr, + "get_code".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_code" } + } + } + + val getDefaultTextureParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shader".cstr.ptr, + "get_default_texture_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_default_texture_param" } + } + } + + val getMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shader".cstr.ptr, + "get_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mode" } + } + } + + val hasParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shader".cstr.ptr, + "has_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_param" } + } + } + + val setCode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shader".cstr.ptr, + "set_code".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_code" } + } + } + + val setDefaultTextureParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shader".cstr.ptr, + "set_default_texture_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_default_texture_param" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ShaderMaterial.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ShaderMaterial.kt index b855ab89..970de026 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ShaderMaterial.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ShaderMaterial.kt @@ -122,47 +122,59 @@ open class ShaderMaterial( * Container for method_bind pointers for ShaderMaterial */ private object __method_bind { - val getShader: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShaderMaterial".cstr.ptr, - "get_shader".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shader" } - } - val getShaderParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShaderMaterial".cstr.ptr, - "get_shader_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shader_param" } - } - val propertyCanRevert: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShaderMaterial".cstr.ptr, - "property_can_revert".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method property_can_revert" } - } - val propertyGetRevert: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShaderMaterial".cstr.ptr, - "property_get_revert".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method property_get_revert" } - } - val setShader: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShaderMaterial".cstr.ptr, - "set_shader".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shader" } - } - val setShaderParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShaderMaterial".cstr.ptr, - "set_shader_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shader_param" } - }} + val getShader: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShaderMaterial".cstr.ptr, + "get_shader".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shader" } + } + } + + val getShaderParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShaderMaterial".cstr.ptr, + "get_shader_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shader_param" } + } + } + + val propertyCanRevert: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShaderMaterial".cstr.ptr, + "property_can_revert".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method property_can_revert" } + } + } + + val propertyGetRevert: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShaderMaterial".cstr.ptr, + "property_get_revert".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method property_get_revert" } + } + } + + val setShader: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShaderMaterial".cstr.ptr, + "set_shader".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shader" } + } + } + + val setShaderParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShaderMaterial".cstr.ptr, + "set_shader_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shader_param" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Shape.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Shape.kt index c542773b..197d7373 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Shape.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Shape.kt @@ -67,17 +67,21 @@ open class Shape( * Container for method_bind pointers for Shape */ private object __method_bind { - val getMargin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shape".cstr.ptr, - "get_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_margin" } - } - val setMargin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shape".cstr.ptr, - "set_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_margin" } - }} + val getMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shape".cstr.ptr, + "get_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_margin" } + } + } + + val setMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shape".cstr.ptr, + "set_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_margin" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Shape2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Shape2D.kt index 0cb97188..b72765c5 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Shape2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Shape2D.kt @@ -152,42 +152,60 @@ open class Shape2D( * Container for method_bind pointers for Shape2D */ private object __method_bind { - val collide: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shape2D".cstr.ptr, - "collide".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method collide" } - } - val collideAndGetContacts: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shape2D".cstr.ptr, - "collide_and_get_contacts".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method collide_and_get_contacts" } - } - val collideWithMotion: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shape2D".cstr.ptr, - "collide_with_motion".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method collide_with_motion" } - } - val collideWithMotionAndGetContacts: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shape2D".cstr.ptr, - "collide_with_motion_and_get_contacts".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method collide_with_motion_and_get_contacts" } - } - val getCustomSolverBias: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shape2D".cstr.ptr, - "get_custom_solver_bias".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_custom_solver_bias" } - } - val setCustomSolverBias: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shape2D".cstr.ptr, - "set_custom_solver_bias".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_custom_solver_bias" } - }} + val collide: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shape2D".cstr.ptr, + "collide".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method collide" } + } + } + + val collideAndGetContacts: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shape2D".cstr.ptr, + "collide_and_get_contacts".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method collide_and_get_contacts" } + } + } + + val collideWithMotion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shape2D".cstr.ptr, + "collide_with_motion".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method collide_with_motion" } + } + } + + val collideWithMotionAndGetContacts: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shape2D".cstr.ptr, + "collide_with_motion_and_get_contacts".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method collide_with_motion_and_get_contacts" } + } + } + + val getCustomSolverBias: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shape2D".cstr.ptr, + "get_custom_solver_bias".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_custom_solver_bias" } + } + } + + val setCustomSolverBias: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Shape2D".cstr.ptr, + "set_custom_solver_bias".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_custom_solver_bias" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ShortCut.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ShortCut.kt index c1dd14d0..3182b1f2 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ShortCut.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ShortCut.kt @@ -106,35 +106,50 @@ open class ShortCut( * Container for method_bind pointers for ShortCut */ private object __method_bind { - val getAsText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShortCut".cstr.ptr, - "get_as_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_as_text" } - } - val getShortcut: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShortCut".cstr.ptr, - "get_shortcut".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shortcut" } - } - val isShortcut: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShortCut".cstr.ptr, - "is_shortcut".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_shortcut" } - } - val isValid: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShortCut".cstr.ptr, - "is_valid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_valid" } - } - val setShortcut: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShortCut".cstr.ptr, - "set_shortcut".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shortcut" } - }} + val getAsText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShortCut".cstr.ptr, + "get_as_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_as_text" } + } + } + + val getShortcut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShortCut".cstr.ptr, + "get_shortcut".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shortcut" } + } + } + + val isShortcut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShortCut".cstr.ptr, + "is_shortcut".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_shortcut" } + } + } + + val isValid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShortCut".cstr.ptr, + "is_valid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_valid" } + } + } + + val setShortcut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ShortCut".cstr.ptr, + "set_shortcut".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shortcut" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Skeleton.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Skeleton.kt index e4ca28e1..b5a3c57f 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Skeleton.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Skeleton.kt @@ -316,169 +316,254 @@ open class Skeleton( * Container for method_bind pointers for Skeleton */ private object __method_bind { - val addBone: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "add_bone".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_bone" } - } - val bindChildNodeToBone: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "bind_child_node_to_bone".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method bind_child_node_to_bone" } - } - val clearBones: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "clear_bones".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_bones" } - } - val findBone: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "find_bone".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method find_bone" } - } - val getBoneCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "get_bone_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bone_count" } - } - val getBoneCustomPose: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "get_bone_custom_pose".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bone_custom_pose" } - } - val getBoneGlobalPose: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "get_bone_global_pose".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bone_global_pose" } - } - val getBoneName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "get_bone_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bone_name" } - } - val getBoneParent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "get_bone_parent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bone_parent" } - } - val getBonePose: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "get_bone_pose".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bone_pose" } - } - val getBoneRest: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "get_bone_rest".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bone_rest" } - } - val getBoundChildNodesToBone: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "get_bound_child_nodes_to_bone".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bound_child_nodes_to_bone" } - } - val isBoneRestDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "is_bone_rest_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_bone_rest_disabled" } - } - val localizeRests: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "localize_rests".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method localize_rests" } - } - val physicalBonesAddCollisionException: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "physical_bones_add_collision_exception".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method physical_bones_add_collision_exception" } - } - val physicalBonesRemoveCollisionException: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "physical_bones_remove_collision_exception".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method physical_bones_remove_collision_exception" } - } - val physicalBonesStartSimulation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "physical_bones_start_simulation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method physical_bones_start_simulation" } - } - val physicalBonesStopSimulation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "physical_bones_stop_simulation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method physical_bones_stop_simulation" } - } - val registerSkin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "register_skin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method register_skin" } - } - val setBoneCustomPose: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "set_bone_custom_pose".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bone_custom_pose" } - } - val setBoneDisableRest: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "set_bone_disable_rest".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bone_disable_rest" } - } - val setBoneGlobalPoseOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "set_bone_global_pose_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bone_global_pose_override" } - } - val setBoneParent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "set_bone_parent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bone_parent" } - } - val setBonePose: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "set_bone_pose".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bone_pose" } - } - val setBoneRest: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "set_bone_rest".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bone_rest" } - } - val unbindChildNodeFromBone: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "unbind_child_node_from_bone".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method unbind_child_node_from_bone" } - } - val unparentBoneAndRest: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, - "unparent_bone_and_rest".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method unparent_bone_and_rest" } - }} + val addBone: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "add_bone".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_bone" } + } + } + + val bindChildNodeToBone: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "bind_child_node_to_bone".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method bind_child_node_to_bone" } + } + } + + val clearBones: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "clear_bones".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_bones" } + } + } + + val findBone: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "find_bone".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method find_bone" } + } + } + + val getBoneCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "get_bone_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bone_count" } + } + } + + val getBoneCustomPose: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "get_bone_custom_pose".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bone_custom_pose" } + } + } + + val getBoneGlobalPose: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "get_bone_global_pose".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bone_global_pose" } + } + } + + val getBoneName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "get_bone_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bone_name" } + } + } + + val getBoneParent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "get_bone_parent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bone_parent" } + } + } + + val getBonePose: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "get_bone_pose".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bone_pose" } + } + } + + val getBoneRest: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "get_bone_rest".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bone_rest" } + } + } + + val getBoundChildNodesToBone: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "get_bound_child_nodes_to_bone".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bound_child_nodes_to_bone" + } + } + } + + val isBoneRestDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "is_bone_rest_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_bone_rest_disabled" } + } + } + + val localizeRests: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "localize_rests".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method localize_rests" } + } + } + + val physicalBonesAddCollisionException: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "physical_bones_add_collision_exception".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method physical_bones_add_collision_exception" } + } + } + + val physicalBonesRemoveCollisionException: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "physical_bones_remove_collision_exception".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method physical_bones_remove_collision_exception" } + } + } + + val physicalBonesStartSimulation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "physical_bones_start_simulation".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method physical_bones_start_simulation" } + } + } + + val physicalBonesStopSimulation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "physical_bones_stop_simulation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method physical_bones_stop_simulation" + } + } + } + + val registerSkin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "register_skin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method register_skin" } + } + } + + val setBoneCustomPose: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "set_bone_custom_pose".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bone_custom_pose" } + } + } + + val setBoneDisableRest: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "set_bone_disable_rest".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bone_disable_rest" } + } + } + + val setBoneGlobalPoseOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "set_bone_global_pose_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bone_global_pose_override" + } + } + } + + val setBoneParent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "set_bone_parent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bone_parent" } + } + } + + val setBonePose: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "set_bone_pose".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bone_pose" } + } + } + + val setBoneRest: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "set_bone_rest".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bone_rest" } + } + } + + val unbindChildNodeFromBone: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "unbind_child_node_from_bone".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method unbind_child_node_from_bone" } + } + } + + val unparentBoneAndRest: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton".cstr.ptr, + "unparent_bone_and_rest".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method unparent_bone_and_rest" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Skeleton2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Skeleton2D.kt index 9403bd29..00ef6c59 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Skeleton2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Skeleton2D.kt @@ -95,23 +95,32 @@ open class Skeleton2D( * Container for method_bind pointers for Skeleton2D */ private object __method_bind { - val getBone: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton2D".cstr.ptr, - "get_bone".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bone" } - } - val getBoneCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton2D".cstr.ptr, - "get_bone_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bone_count" } - } - val getSkeleton: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton2D".cstr.ptr, - "get_skeleton".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_skeleton" } - }} + val getBone: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton2D".cstr.ptr, + "get_bone".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bone" } + } + } + + val getBoneCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton2D".cstr.ptr, + "get_bone_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bone_count" } + } + } + + val getSkeleton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skeleton2D".cstr.ptr, + "get_skeleton".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_skeleton" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/SkeletonIK.kt b/godot-kotlin/src/nativeGen/kotlin/godot/SkeletonIK.kt index 56e2238a..738af84e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/SkeletonIK.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/SkeletonIK.kt @@ -372,149 +372,221 @@ open class SkeletonIK( * Container for method_bind pointers for SkeletonIK */ private object __method_bind { - val getInterpolation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "get_interpolation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_interpolation" } - } - val getMagnetPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "get_magnet_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_magnet_position" } - } - val getMaxIterations: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "get_max_iterations".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_max_iterations" } - } - val getMinDistance: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "get_min_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_min_distance" } - } - val getParentSkeleton: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "get_parent_skeleton".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_parent_skeleton" } - } - val getRootBone: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "get_root_bone".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_root_bone" } - } - val getTargetNode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "get_target_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_target_node" } - } - val getTargetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "get_target_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_target_transform" } - } - val getTipBone: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "get_tip_bone".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tip_bone" } - } - val isOverrideTipBasis: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "is_override_tip_basis".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_override_tip_basis" } - } - val isRunning: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "is_running".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_running" } - } - val isUsingMagnet: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "is_using_magnet".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_using_magnet" } - } - val setInterpolation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "set_interpolation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_interpolation" } - } - val setMagnetPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "set_magnet_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_magnet_position" } - } - val setMaxIterations: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "set_max_iterations".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_max_iterations" } - } - val setMinDistance: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "set_min_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_min_distance" } - } - val setOverrideTipBasis: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "set_override_tip_basis".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_override_tip_basis" } - } - val setRootBone: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "set_root_bone".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_root_bone" } - } - val setTargetNode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "set_target_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_target_node" } - } - val setTargetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "set_target_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_target_transform" } - } - val setTipBone: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "set_tip_bone".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tip_bone" } - } - val setUseMagnet: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "set_use_magnet".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_magnet" } - } - val start: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "start".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method start" } - } - val stop: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, - "stop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method stop" } - }} + val getInterpolation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "get_interpolation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_interpolation" } + } + } + + val getMagnetPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "get_magnet_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_magnet_position" } + } + } + + val getMaxIterations: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "get_max_iterations".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_max_iterations" } + } + } + + val getMinDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "get_min_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_min_distance" } + } + } + + val getParentSkeleton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "get_parent_skeleton".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_parent_skeleton" } + } + } + + val getRootBone: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "get_root_bone".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_root_bone" } + } + } + + val getTargetNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "get_target_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_target_node" } + } + } + + val getTargetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "get_target_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_target_transform" } + } + } + + val getTipBone: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "get_tip_bone".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tip_bone" } + } + } + + val isOverrideTipBasis: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "is_override_tip_basis".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_override_tip_basis" } + } + } + + val isRunning: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "is_running".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_running" } + } + } + + val isUsingMagnet: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "is_using_magnet".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_using_magnet" } + } + } + + val setInterpolation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "set_interpolation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_interpolation" } + } + } + + val setMagnetPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "set_magnet_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_magnet_position" } + } + } + + val setMaxIterations: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "set_max_iterations".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_max_iterations" } + } + } + + val setMinDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "set_min_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_min_distance" } + } + } + + val setOverrideTipBasis: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "set_override_tip_basis".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_override_tip_basis" } + } + } + + val setRootBone: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "set_root_bone".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_root_bone" } + } + } + + val setTargetNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "set_target_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_target_node" } + } + } + + val setTargetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "set_target_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_target_transform" } + } + } + + val setTipBone: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "set_tip_bone".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tip_bone" } + } + } + + val setUseMagnet: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "set_use_magnet".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_magnet" } + } + } + + val start: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "start".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method start" } + } + } + + val stop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkeletonIK".cstr.ptr, + "stop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method stop" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Skin.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Skin.kt index e40b2633..3749cd19 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Skin.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Skin.kt @@ -124,53 +124,69 @@ open class Skin( * Container for method_bind pointers for Skin */ private object __method_bind { - val addBind: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skin".cstr.ptr, - "add_bind".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_bind" } - } - val clearBinds: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skin".cstr.ptr, - "clear_binds".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_binds" } - } - val getBindBone: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skin".cstr.ptr, - "get_bind_bone".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bind_bone" } - } - val getBindCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skin".cstr.ptr, - "get_bind_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bind_count" } - } - val getBindPose: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skin".cstr.ptr, - "get_bind_pose".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bind_pose" } - } - val setBindBone: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skin".cstr.ptr, - "set_bind_bone".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bind_bone" } - } - val setBindCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skin".cstr.ptr, - "set_bind_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bind_count" } - } - val setBindPose: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skin".cstr.ptr, - "set_bind_pose".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bind_pose" } - }} + val addBind: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skin".cstr.ptr, + "add_bind".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_bind" } + } + } + + val clearBinds: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skin".cstr.ptr, + "clear_binds".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_binds" } + } + } + + val getBindBone: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skin".cstr.ptr, + "get_bind_bone".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bind_bone" } + } + } + + val getBindCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skin".cstr.ptr, + "get_bind_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bind_count" } + } + } + + val getBindPose: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skin".cstr.ptr, + "get_bind_pose".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bind_pose" } + } + } + + val setBindBone: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skin".cstr.ptr, + "set_bind_bone".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bind_bone" } + } + } + + val setBindCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skin".cstr.ptr, + "set_bind_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bind_count" } + } + } + + val setBindPose: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Skin".cstr.ptr, + "set_bind_pose".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bind_pose" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/SkinReference.kt b/godot-kotlin/src/nativeGen/kotlin/godot/SkinReference.kt index fbb3209d..acdae5dc 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/SkinReference.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/SkinReference.kt @@ -69,19 +69,23 @@ open class SkinReference( * Container for method_bind pointers for SkinReference */ private object __method_bind { - val getSkeleton: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkinReference".cstr.ptr, - "get_skeleton".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_skeleton" } - } - val getSkin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkinReference".cstr.ptr, - "get_skin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_skin" } - }} + val getSkeleton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkinReference".cstr.ptr, + "get_skeleton".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_skeleton" } + } + } + + val getSkin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SkinReference".cstr.ptr, + "get_skin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_skin" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Sky.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Sky.kt index b98d9716..4a405b23 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Sky.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Sky.kt @@ -98,17 +98,21 @@ open class Sky( * Container for method_bind pointers for Sky */ private object __method_bind { - val getRadianceSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sky".cstr.ptr, - "get_radiance_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_radiance_size" } - } - val setRadianceSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sky".cstr.ptr, - "set_radiance_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_radiance_size" } - }} + val getRadianceSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sky".cstr.ptr, + "get_radiance_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_radiance_size" } + } + } + + val setRadianceSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sky".cstr.ptr, + "set_radiance_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_radiance_size" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Slider.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Slider.kt index bd9c5445..94f0e2f4 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Slider.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Slider.kt @@ -143,53 +143,69 @@ open class Slider( * Container for method_bind pointers for Slider */ private object __method_bind { - val getTicks: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Slider".cstr.ptr, - "get_ticks".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ticks" } - } - val getTicksOnBorders: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Slider".cstr.ptr, - "get_ticks_on_borders".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ticks_on_borders" } - } - val isEditable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Slider".cstr.ptr, - "is_editable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_editable" } - } - val isScrollable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Slider".cstr.ptr, - "is_scrollable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_scrollable" } - } - val setEditable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Slider".cstr.ptr, - "set_editable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_editable" } - } - val setScrollable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Slider".cstr.ptr, - "set_scrollable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_scrollable" } - } - val setTicks: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Slider".cstr.ptr, - "set_ticks".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ticks" } - } - val setTicksOnBorders: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Slider".cstr.ptr, - "set_ticks_on_borders".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ticks_on_borders" } - }} + val getTicks: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Slider".cstr.ptr, + "get_ticks".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ticks" } + } + } + + val getTicksOnBorders: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Slider".cstr.ptr, + "get_ticks_on_borders".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ticks_on_borders" } + } + } + + val isEditable: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Slider".cstr.ptr, + "is_editable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_editable" } + } + } + + val isScrollable: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Slider".cstr.ptr, + "is_scrollable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_scrollable" } + } + } + + val setEditable: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Slider".cstr.ptr, + "set_editable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_editable" } + } + } + + val setScrollable: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Slider".cstr.ptr, + "set_scrollable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_scrollable" } + } + } + + val setTicks: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Slider".cstr.ptr, + "set_ticks".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ticks" } + } + } + + val setTicksOnBorders: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Slider".cstr.ptr, + "set_ticks_on_borders".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ticks_on_borders" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/SliderJoint.kt b/godot-kotlin/src/nativeGen/kotlin/godot/SliderJoint.kt index c519b993..8e1f98ef 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/SliderJoint.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/SliderJoint.kt @@ -306,19 +306,23 @@ open class SliderJoint( * Container for method_bind pointers for SliderJoint */ private object __method_bind { - val getParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SliderJoint".cstr.ptr, - "get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_param" } - } - val setParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SliderJoint".cstr.ptr, - "set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_param" } - }} + val getParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SliderJoint".cstr.ptr, + "get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_param" } + } + } + + val setParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SliderJoint".cstr.ptr, + "set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_param" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/SoftBody.kt b/godot-kotlin/src/nativeGen/kotlin/godot/SoftBody.kt index f491b535..7416eb28 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/SoftBody.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/SoftBody.kt @@ -457,203 +457,305 @@ open class SoftBody( * Container for method_bind pointers for SoftBody */ private object __method_bind { - val addCollisionExceptionWith: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "add_collision_exception_with".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_collision_exception_with" } - } - val getAreaAngularStiffness: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "get_areaAngular_stiffness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_areaAngular_stiffness" } - } - val getCollisionExceptions: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "get_collision_exceptions".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_exceptions" } - } - val getCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "get_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_layer" } - } - val getCollisionLayerBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "get_collision_layer_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_layer_bit" } - } - val getCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "get_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } - } - val getCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "get_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } - } - val getDampingCoefficient: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "get_damping_coefficient".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_damping_coefficient" } - } - val getDragCoefficient: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "get_drag_coefficient".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_drag_coefficient" } - } - val getLinearStiffness: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "get_linear_stiffness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_linear_stiffness" } - } - val getParentCollisionIgnore: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "get_parent_collision_ignore".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_parent_collision_ignore" } - } - val getPoseMatchingCoefficient: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "get_pose_matching_coefficient".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pose_matching_coefficient" } - } - val getPressureCoefficient: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "get_pressure_coefficient".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pressure_coefficient" } - } - val getSimulationPrecision: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "get_simulation_precision".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_simulation_precision" } - } - val getTotalMass: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "get_total_mass".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_total_mass" } - } - val getVolumeStiffness: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "get_volume_stiffness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_volume_stiffness" } - } - val isRayPickable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "is_ray_pickable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_ray_pickable" } - } - val removeCollisionExceptionWith: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "remove_collision_exception_with".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_collision_exception_with" } - } - val setAreaAngularStiffness: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "set_areaAngular_stiffness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_areaAngular_stiffness" } - } - val setCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "set_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_layer" } - } - val setCollisionLayerBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "set_collision_layer_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_layer_bit" } - } - val setCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "set_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } - } - val setCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "set_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } - } - val setDampingCoefficient: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "set_damping_coefficient".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_damping_coefficient" } - } - val setDragCoefficient: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "set_drag_coefficient".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_drag_coefficient" } - } - val setLinearStiffness: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "set_linear_stiffness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_linear_stiffness" } - } - val setParentCollisionIgnore: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "set_parent_collision_ignore".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_parent_collision_ignore" } - } - val setPoseMatchingCoefficient: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "set_pose_matching_coefficient".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pose_matching_coefficient" } - } - val setPressureCoefficient: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "set_pressure_coefficient".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pressure_coefficient" } - } - val setRayPickable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "set_ray_pickable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ray_pickable" } - } - val setSimulationPrecision: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "set_simulation_precision".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_simulation_precision" } - } - val setTotalMass: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "set_total_mass".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_total_mass" } - } - val setVolumeStiffness: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, - "set_volume_stiffness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_volume_stiffness" } - }} + val addCollisionExceptionWith: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "add_collision_exception_with".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_collision_exception_with" } + } + } + + val getAreaAngularStiffness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "get_areaAngular_stiffness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_areaAngular_stiffness" } + } + } + + val getCollisionExceptions: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "get_collision_exceptions".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_exceptions" } + } + } + + val getCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "get_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_layer" } + } + } + + val getCollisionLayerBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "get_collision_layer_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_layer_bit" } + } + } + + val getCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "get_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } + } + } + + val getCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "get_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } + } + } + + val getDampingCoefficient: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "get_damping_coefficient".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_damping_coefficient" } + } + } + + val getDragCoefficient: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "get_drag_coefficient".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_drag_coefficient" } + } + } + + val getLinearStiffness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "get_linear_stiffness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_linear_stiffness" } + } + } + + val getParentCollisionIgnore: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "get_parent_collision_ignore".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_parent_collision_ignore" } + } + } + + val getPoseMatchingCoefficient: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "get_pose_matching_coefficient".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pose_matching_coefficient" + } + } + } + + val getPressureCoefficient: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "get_pressure_coefficient".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pressure_coefficient" } + } + } + + val getSimulationPrecision: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "get_simulation_precision".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_simulation_precision" } + } + } + + val getTotalMass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "get_total_mass".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_total_mass" } + } + } + + val getVolumeStiffness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "get_volume_stiffness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_volume_stiffness" } + } + } + + val isRayPickable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "is_ray_pickable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_ray_pickable" } + } + } + + val removeCollisionExceptionWith: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "remove_collision_exception_with".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method remove_collision_exception_with" } + } + } + + val setAreaAngularStiffness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "set_areaAngular_stiffness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_areaAngular_stiffness" } + } + } + + val setCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "set_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_layer" } + } + } + + val setCollisionLayerBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "set_collision_layer_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_layer_bit" } + } + } + + val setCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "set_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } + } + } + + val setCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "set_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } + } + } + + val setDampingCoefficient: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "set_damping_coefficient".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_damping_coefficient" } + } + } + + val setDragCoefficient: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "set_drag_coefficient".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_drag_coefficient" } + } + } + + val setLinearStiffness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "set_linear_stiffness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_linear_stiffness" } + } + } + + val setParentCollisionIgnore: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "set_parent_collision_ignore".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_parent_collision_ignore" } + } + } + + val setPoseMatchingCoefficient: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "set_pose_matching_coefficient".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pose_matching_coefficient" + } + } + } + + val setPressureCoefficient: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "set_pressure_coefficient".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pressure_coefficient" } + } + } + + val setRayPickable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "set_ray_pickable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ray_pickable" } + } + } + + val setSimulationPrecision: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "set_simulation_precision".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_simulation_precision" } + } + } + + val setTotalMass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "set_total_mass".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_total_mass" } + } + } + + val setVolumeStiffness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SoftBody".cstr.ptr, + "set_volume_stiffness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_volume_stiffness" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Spatial.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Spatial.kt index d48b5813..b9b8591b 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Spatial.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Spatial.kt @@ -616,302 +616,449 @@ open class Spatial( * Container for method_bind pointers for Spatial */ private object __method_bind { - val forceUpdateTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "force_update_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method force_update_transform" } - } - val getGizmo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "get_gizmo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gizmo" } - } - val getGlobalTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "get_global_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_global_transform" } - } - val getParentSpatial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "get_parent_spatial".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_parent_spatial" } - } - val getRotation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "get_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rotation" } - } - val getRotationDegrees: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "get_rotation_degrees".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rotation_degrees" } - } - val getScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "get_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_scale" } - } - val getTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "get_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_transform" } - } - val getTranslation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "get_translation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_translation" } - } - val getWorld: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "get_world".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_world" } - } - val globalRotate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "global_rotate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method global_rotate" } - } - val globalScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "global_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method global_scale" } - } - val globalTranslate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "global_translate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method global_translate" } - } - val hide: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "hide".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method hide" } - } - val isLocalTransformNotificationEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "is_local_transform_notification_enabled".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method is_local_transform_notification_enabled" } - } - val isScaleDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "is_scale_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_scale_disabled" } - } - val isSetAsToplevel: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "is_set_as_toplevel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_set_as_toplevel" } - } - val isTransformNotificationEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "is_transform_notification_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_transform_notification_enabled" - } - } - val isVisible: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "is_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_visible" } - } - val isVisibleInTree: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "is_visible_in_tree".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_visible_in_tree" } - } - val lookAt: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "look_at".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method look_at" } - } - val lookAtFromPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "look_at_from_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method look_at_from_position" } - } - val orthonormalize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "orthonormalize".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method orthonormalize" } - } - val rotate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "rotate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rotate" } - } - val rotateObjectLocal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "rotate_object_local".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rotate_object_local" } - } - val rotateX: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "rotate_x".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rotate_x" } - } - val rotateY: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "rotate_y".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rotate_y" } - } - val rotateZ: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "rotate_z".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rotate_z" } - } - val scaleObjectLocal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "scale_object_local".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method scale_object_local" } - } - val setAsToplevel: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "set_as_toplevel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_as_toplevel" } - } - val setDisableScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "set_disable_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_disable_scale" } - } - val setGizmo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "set_gizmo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_gizmo" } - } - val setGlobalTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "set_global_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_global_transform" } - } - val setIdentity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "set_identity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_identity" } - } - val setIgnoreTransformNotification: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "set_ignore_transform_notification".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ignore_transform_notification" - } - } - val setNotifyLocalTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "set_notify_local_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_notify_local_transform" } - } - val setNotifyTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "set_notify_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_notify_transform" } - } - val setRotation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "set_rotation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rotation" } - } - val setRotationDegrees: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "set_rotation_degrees".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rotation_degrees" } - } - val setScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "set_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_scale" } - } - val setTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_transform" } - } - val setTranslation: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "set_translation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_translation" } - } - val setVisible: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "set_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_visible" } - } - val show: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "show".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method show" } - } - val toGlobal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "to_global".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method to_global" } - } - val toLocal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "to_local".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method to_local" } - } - val translate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "translate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method translate" } - } - val translateObjectLocal: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "translate_object_local".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method translate_object_local" } - } - val updateGizmo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, - "update_gizmo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method update_gizmo" } - }} + val forceUpdateTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "force_update_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method force_update_transform" } + } + } + + val getGizmo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "get_gizmo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gizmo" } + } + } + + val getGlobalTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "get_global_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_global_transform" } + } + } + + val getParentSpatial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "get_parent_spatial".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_parent_spatial" } + } + } + + val getRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "get_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rotation" } + } + } + + val getRotationDegrees: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "get_rotation_degrees".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rotation_degrees" } + } + } + + val getScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "get_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_scale" } + } + } + + val getTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "get_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_transform" } + } + } + + val getTranslation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "get_translation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_translation" } + } + } + + val getWorld: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "get_world".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_world" } + } + } + + val globalRotate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "global_rotate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method global_rotate" } + } + } + + val globalScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "global_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method global_scale" } + } + } + + val globalTranslate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "global_translate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method global_translate" } + } + } + + val hide: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "hide".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method hide" } + } + } + + val isLocalTransformNotificationEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "is_local_transform_notification_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_local_transform_notification_enabled" } + } + } + + val isScaleDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "is_scale_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_scale_disabled" } + } + } + + val isSetAsToplevel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "is_set_as_toplevel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_set_as_toplevel" } + } + } + + val isTransformNotificationEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "is_transform_notification_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_transform_notification_enabled" } + } + } + + val isVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "is_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_visible" } + } + } + + val isVisibleInTree: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "is_visible_in_tree".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_visible_in_tree" } + } + } + + val lookAt: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "look_at".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method look_at" } + } + } + + val lookAtFromPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "look_at_from_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method look_at_from_position" } + } + } + + val orthonormalize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "orthonormalize".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method orthonormalize" } + } + } + + val rotate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "rotate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rotate" } + } + } + + val rotateObjectLocal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "rotate_object_local".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rotate_object_local" } + } + } + + val rotateX: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "rotate_x".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rotate_x" } + } + } + + val rotateY: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "rotate_y".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rotate_y" } + } + } + + val rotateZ: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "rotate_z".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rotate_z" } + } + } + + val scaleObjectLocal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "scale_object_local".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method scale_object_local" } + } + } + + val setAsToplevel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "set_as_toplevel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_as_toplevel" } + } + } + + val setDisableScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "set_disable_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_disable_scale" } + } + } + + val setGizmo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "set_gizmo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_gizmo" } + } + } + + val setGlobalTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "set_global_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_global_transform" } + } + } + + val setIdentity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "set_identity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_identity" } + } + } + + val setIgnoreTransformNotification: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "set_ignore_transform_notification".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_ignore_transform_notification" } + } + } + + val setNotifyLocalTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "set_notify_local_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_notify_local_transform" } + } + } + + val setNotifyTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "set_notify_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_notify_transform" } + } + } + + val setRotation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "set_rotation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rotation" } + } + } + + val setRotationDegrees: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "set_rotation_degrees".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rotation_degrees" } + } + } + + val setScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "set_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_scale" } + } + } + + val setTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_transform" } + } + } + + val setTranslation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "set_translation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_translation" } + } + } + + val setVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "set_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_visible" } + } + } + + val show: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "show".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method show" } + } + } + + val toGlobal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "to_global".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method to_global" } + } + } + + val toLocal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "to_local".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method to_local" } + } + } + + val translate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "translate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method translate" } + } + } + + val translateObjectLocal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "translate_object_local".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method translate_object_local" } + } + } + + val updateGizmo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Spatial".cstr.ptr, + "update_gizmo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method update_gizmo" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/SpatialMaterial.kt b/godot-kotlin/src/nativeGen/kotlin/godot/SpatialMaterial.kt index 1885ff14..28bf31a8 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/SpatialMaterial.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/SpatialMaterial.kt @@ -2283,817 +2283,1054 @@ open class SpatialMaterial( * Container for method_bind pointers for SpatialMaterial */ private object __method_bind { - val getAlbedo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_albedo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_albedo" } - } - val getAlphaScissorThreshold: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_alpha_scissor_threshold".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_alpha_scissor_threshold" } - } - val getAnisotropy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_anisotropy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_anisotropy" } - } - val getAoLightAffect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_ao_light_affect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ao_light_affect" } - } - val getAoTextureChannel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_ao_texture_channel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ao_texture_channel" } - } - val getBillboardMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_billboard_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_billboard_mode" } - } - val getBlendMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_blend_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_blend_mode" } - } - val getClearcoat: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_clearcoat".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_clearcoat" } - } - val getClearcoatGloss: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_clearcoat_gloss".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_clearcoat_gloss" } - } - val getCullMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_cull_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cull_mode" } - } - val getDepthDeepParallaxFlipBinormal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_depth_deep_parallax_flip_binormal".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method get_depth_deep_parallax_flip_binormal" } - } - val getDepthDeepParallaxFlipTangent: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_depth_deep_parallax_flip_tangent".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method get_depth_deep_parallax_flip_tangent" } - } - val getDepthDeepParallaxMaxLayers: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_depth_deep_parallax_max_layers".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_depth_deep_parallax_max_layers" + val getAlbedo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_albedo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_albedo" } } - } - val getDepthDeepParallaxMinLayers: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_depth_deep_parallax_min_layers".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_depth_deep_parallax_min_layers" + } + + val getAlphaScissorThreshold: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_alpha_scissor_threshold".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_alpha_scissor_threshold" } } - } - val getDepthDrawMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_depth_draw_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_depth_draw_mode" } - } - val getDepthScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_depth_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_depth_scale" } - } - val getDetailBlendMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_detail_blend_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_detail_blend_mode" } - } - val getDetailUv: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_detail_uv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_detail_uv" } - } - val getDiffuseMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_diffuse_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_diffuse_mode" } - } - val getDistanceFade: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_distance_fade".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_distance_fade" } - } - val getDistanceFadeMaxDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_distance_fade_max_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_distance_fade_max_distance" } - } - val getDistanceFadeMinDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_distance_fade_min_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_distance_fade_min_distance" } - } - val getEmission: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_emission".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission" } - } - val getEmissionEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_emission_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_energy" } - } - val getEmissionOperator: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_emission_operator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_emission_operator" } - } - val getFeature: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_feature".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_feature" } - } - val getFlag: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_flag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_flag" } - } - val getGrow: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_grow".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_grow" } - } - val getLineWidth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_line_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_line_width" } - } - val getMetallic: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_metallic".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_metallic" } - } - val getMetallicTextureChannel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_metallic_texture_channel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_metallic_texture_channel" } - } - val getNormalScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_normal_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_normal_scale" } - } - val getParticlesAnimHFrames: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_particles_anim_h_frames".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_particles_anim_h_frames" } - } - val getParticlesAnimLoop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_particles_anim_loop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_particles_anim_loop" } - } - val getParticlesAnimVFrames: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_particles_anim_v_frames".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_particles_anim_v_frames" } - } - val getPointSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_point_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_point_size" } - } - val getProximityFadeDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_proximity_fade_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_proximity_fade_distance" } - } - val getRefraction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_refraction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_refraction" } - } - val getRefractionTextureChannel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_refraction_texture_channel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_refraction_texture_channel" } - } - val getRim: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_rim".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rim" } - } - val getRimTint: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_rim_tint".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rim_tint" } - } - val getRoughness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_roughness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_roughness" } - } - val getRoughnessTextureChannel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_roughness_texture_channel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_roughness_texture_channel" } - } - val getSpecular: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_specular".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_specular" } - } - val getSpecularMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_specular_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_specular_mode" } - } - val getSubsurfaceScatteringStrength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_subsurface_scattering_strength".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_subsurface_scattering_strength" + } + + val getAnisotropy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_anisotropy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_anisotropy" } } - } - val getTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture" } - } - val getTransmission: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_transmission".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_transmission" } - } - val getUv1Offset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_uv1_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_uv1_offset" } - } - val getUv1Scale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_uv1_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_uv1_scale" } - } - val getUv1TriplanarBlendSharpness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_uv1_triplanar_blend_sharpness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_uv1_triplanar_blend_sharpness" + } + + val getAoLightAffect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_ao_light_affect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ao_light_affect" } } - } - val getUv2Offset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_uv2_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_uv2_offset" } - } - val getUv2Scale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_uv2_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_uv2_scale" } - } - val getUv2TriplanarBlendSharpness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "get_uv2_triplanar_blend_sharpness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_uv2_triplanar_blend_sharpness" + } + + val getAoTextureChannel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_ao_texture_channel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ao_texture_channel" } } - } - val isDepthDeepParallaxEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "is_depth_deep_parallax_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_depth_deep_parallax_enabled" } - } - val isGrowEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "is_grow_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_grow_enabled" } - } - val isProximityFadeEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "is_proximity_fade_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_proximity_fade_enabled" } - } - val setAlbedo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_albedo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_albedo" } - } - val setAlphaScissorThreshold: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_alpha_scissor_threshold".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_alpha_scissor_threshold" } - } - val setAnisotropy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_anisotropy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_anisotropy" } - } - val setAoLightAffect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_ao_light_affect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ao_light_affect" } - } - val setAoTextureChannel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_ao_texture_channel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ao_texture_channel" } - } - val setBillboardMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_billboard_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_billboard_mode" } - } - val setBlendMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_blend_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_blend_mode" } - } - val setClearcoat: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_clearcoat".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_clearcoat" } - } - val setClearcoatGloss: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_clearcoat_gloss".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_clearcoat_gloss" } - } - val setCullMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_cull_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cull_mode" } - } - val setDepthDeepParallax: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_depth_deep_parallax".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_depth_deep_parallax" } - } - val setDepthDeepParallaxFlipBinormal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_depth_deep_parallax_flip_binormal".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method set_depth_deep_parallax_flip_binormal" } - } - val setDepthDeepParallaxFlipTangent: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_depth_deep_parallax_flip_tangent".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method set_depth_deep_parallax_flip_tangent" } - } - val setDepthDeepParallaxMaxLayers: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_depth_deep_parallax_max_layers".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_depth_deep_parallax_max_layers" + } + + val getBillboardMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_billboard_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_billboard_mode" } } - } - val setDepthDeepParallaxMinLayers: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_depth_deep_parallax_min_layers".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_depth_deep_parallax_min_layers" + } + + val getBlendMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_blend_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_blend_mode" } } - } - val setDepthDrawMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_depth_draw_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_depth_draw_mode" } - } - val setDepthScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_depth_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_depth_scale" } - } - val setDetailBlendMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_detail_blend_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_detail_blend_mode" } - } - val setDetailUv: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_detail_uv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_detail_uv" } - } - val setDiffuseMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_diffuse_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_diffuse_mode" } - } - val setDistanceFade: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_distance_fade".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_distance_fade" } - } - val setDistanceFadeMaxDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_distance_fade_max_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_distance_fade_max_distance" } - } - val setDistanceFadeMinDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_distance_fade_min_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_distance_fade_min_distance" } - } - val setEmission: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_emission".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission" } - } - val setEmissionEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_emission_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_energy" } - } - val setEmissionOperator: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_emission_operator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_emission_operator" } - } - val setFeature: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_feature".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_feature" } - } - val setFlag: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_flag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flag" } - } - val setGrow: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_grow".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_grow" } - } - val setGrowEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_grow_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_grow_enabled" } - } - val setLineWidth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_line_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_line_width" } - } - val setMetallic: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_metallic".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_metallic" } - } - val setMetallicTextureChannel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_metallic_texture_channel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_metallic_texture_channel" } - } - val setNormalScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_normal_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_normal_scale" } - } - val setParticlesAnimHFrames: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_particles_anim_h_frames".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_particles_anim_h_frames" } - } - val setParticlesAnimLoop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_particles_anim_loop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_particles_anim_loop" } - } - val setParticlesAnimVFrames: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_particles_anim_v_frames".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_particles_anim_v_frames" } - } - val setPointSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_point_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_point_size" } - } - val setProximityFade: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_proximity_fade".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_proximity_fade" } - } - val setProximityFadeDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_proximity_fade_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_proximity_fade_distance" } - } - val setRefraction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_refraction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_refraction" } - } - val setRefractionTextureChannel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_refraction_texture_channel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_refraction_texture_channel" } - } - val setRim: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_rim".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rim" } - } - val setRimTint: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_rim_tint".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rim_tint" } - } - val setRoughness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_roughness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_roughness" } - } - val setRoughnessTextureChannel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_roughness_texture_channel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_roughness_texture_channel" } - } - val setSpecular: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_specular".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_specular" } - } - val setSpecularMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_specular_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_specular_mode" } - } - val setSubsurfaceScatteringStrength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_subsurface_scattering_strength".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_subsurface_scattering_strength" + } + + val getClearcoat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_clearcoat".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_clearcoat" } } - } - val setTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture" } - } - val setTransmission: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_transmission".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_transmission" } - } - val setUv1Offset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_uv1_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_uv1_offset" } - } - val setUv1Scale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_uv1_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_uv1_scale" } - } - val setUv1TriplanarBlendSharpness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_uv1_triplanar_blend_sharpness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_uv1_triplanar_blend_sharpness" + } + + val getClearcoatGloss: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_clearcoat_gloss".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_clearcoat_gloss" } } - } - val setUv2Offset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_uv2_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_uv2_offset" } - } - val setUv2Scale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_uv2_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_uv2_scale" } - } - val setUv2TriplanarBlendSharpness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, - "set_uv2_triplanar_blend_sharpness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_uv2_triplanar_blend_sharpness" - } - }} + } + + val getCullMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_cull_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cull_mode" } + } + } + + val getDepthDeepParallaxFlipBinormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_depth_deep_parallax_flip_binormal".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_depth_deep_parallax_flip_binormal" } + } + } + + val getDepthDeepParallaxFlipTangent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_depth_deep_parallax_flip_tangent".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_depth_deep_parallax_flip_tangent" } + } + } + + val getDepthDeepParallaxMaxLayers: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_depth_deep_parallax_max_layers".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_depth_deep_parallax_max_layers" } + } + } + + val getDepthDeepParallaxMinLayers: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_depth_deep_parallax_min_layers".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_depth_deep_parallax_min_layers" } + } + } + + val getDepthDrawMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_depth_draw_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_depth_draw_mode" } + } + } + + val getDepthScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_depth_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_depth_scale" } + } + } + + val getDetailBlendMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_detail_blend_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_detail_blend_mode" } + } + } + + val getDetailUv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_detail_uv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_detail_uv" } + } + } + + val getDiffuseMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_diffuse_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_diffuse_mode" } + } + } + + val getDistanceFade: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_distance_fade".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_distance_fade" } + } + } + + val getDistanceFadeMaxDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_distance_fade_max_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_distance_fade_max_distance" + } + } + } + + val getDistanceFadeMinDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_distance_fade_min_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_distance_fade_min_distance" + } + } + } + + val getEmission: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_emission".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission" } + } + } + + val getEmissionEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_emission_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_energy" } + } + } + + val getEmissionOperator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_emission_operator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_emission_operator" } + } + } + + val getFeature: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_feature".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_feature" } + } + } + + val getFlag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_flag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_flag" } + } + } + + val getGrow: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_grow".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_grow" } + } + } + + val getLineWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_line_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_line_width" } + } + } + + val getMetallic: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_metallic".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_metallic" } + } + } + + val getMetallicTextureChannel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_metallic_texture_channel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_metallic_texture_channel" } + } + } + + val getNormalScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_normal_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_normal_scale" } + } + } + + val getParticlesAnimHFrames: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_particles_anim_h_frames".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_particles_anim_h_frames" } + } + } + + val getParticlesAnimLoop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_particles_anim_loop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_particles_anim_loop" } + } + } + + val getParticlesAnimVFrames: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_particles_anim_v_frames".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_particles_anim_v_frames" } + } + } + + val getPointSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_point_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_point_size" } + } + } + + val getProximityFadeDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_proximity_fade_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_proximity_fade_distance" } + } + } + + val getRefraction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_refraction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_refraction" } + } + } + + val getRefractionTextureChannel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_refraction_texture_channel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_refraction_texture_channel" + } + } + } + + val getRim: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_rim".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rim" } + } + } + + val getRimTint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_rim_tint".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rim_tint" } + } + } + + val getRoughness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_roughness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_roughness" } + } + } + + val getRoughnessTextureChannel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_roughness_texture_channel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_roughness_texture_channel" + } + } + } + + val getSpecular: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_specular".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_specular" } + } + } + + val getSpecularMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_specular_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_specular_mode" } + } + } + + val getSubsurfaceScatteringStrength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_subsurface_scattering_strength".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_subsurface_scattering_strength" } + } + } + + val getTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture" } + } + } + + val getTransmission: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_transmission".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_transmission" } + } + } + + val getUv1Offset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_uv1_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_uv1_offset" } + } + } + + val getUv1Scale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_uv1_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_uv1_scale" } + } + } + + val getUv1TriplanarBlendSharpness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_uv1_triplanar_blend_sharpness".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_uv1_triplanar_blend_sharpness" } + } + } + + val getUv2Offset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_uv2_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_uv2_offset" } + } + } + + val getUv2Scale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_uv2_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_uv2_scale" } + } + } + + val getUv2TriplanarBlendSharpness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "get_uv2_triplanar_blend_sharpness".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_uv2_triplanar_blend_sharpness" } + } + } + + val isDepthDeepParallaxEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "is_depth_deep_parallax_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_depth_deep_parallax_enabled" + } + } + } + + val isGrowEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "is_grow_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_grow_enabled" } + } + } + + val isProximityFadeEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "is_proximity_fade_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_proximity_fade_enabled" } + } + } + + val setAlbedo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_albedo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_albedo" } + } + } + + val setAlphaScissorThreshold: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_alpha_scissor_threshold".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_alpha_scissor_threshold" } + } + } + + val setAnisotropy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_anisotropy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_anisotropy" } + } + } + + val setAoLightAffect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_ao_light_affect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ao_light_affect" } + } + } + + val setAoTextureChannel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_ao_texture_channel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ao_texture_channel" } + } + } + + val setBillboardMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_billboard_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_billboard_mode" } + } + } + + val setBlendMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_blend_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_blend_mode" } + } + } + + val setClearcoat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_clearcoat".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_clearcoat" } + } + } + + val setClearcoatGloss: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_clearcoat_gloss".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_clearcoat_gloss" } + } + } + + val setCullMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_cull_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cull_mode" } + } + } + + val setDepthDeepParallax: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_depth_deep_parallax".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_depth_deep_parallax" } + } + } + + val setDepthDeepParallaxFlipBinormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_depth_deep_parallax_flip_binormal".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_depth_deep_parallax_flip_binormal" } + } + } + + val setDepthDeepParallaxFlipTangent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_depth_deep_parallax_flip_tangent".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_depth_deep_parallax_flip_tangent" } + } + } + + val setDepthDeepParallaxMaxLayers: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_depth_deep_parallax_max_layers".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_depth_deep_parallax_max_layers" } + } + } + + val setDepthDeepParallaxMinLayers: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_depth_deep_parallax_min_layers".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_depth_deep_parallax_min_layers" } + } + } + + val setDepthDrawMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_depth_draw_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_depth_draw_mode" } + } + } + + val setDepthScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_depth_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_depth_scale" } + } + } + + val setDetailBlendMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_detail_blend_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_detail_blend_mode" } + } + } + + val setDetailUv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_detail_uv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_detail_uv" } + } + } + + val setDiffuseMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_diffuse_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_diffuse_mode" } + } + } + + val setDistanceFade: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_distance_fade".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_distance_fade" } + } + } + + val setDistanceFadeMaxDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_distance_fade_max_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_distance_fade_max_distance" + } + } + } + + val setDistanceFadeMinDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_distance_fade_min_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_distance_fade_min_distance" + } + } + } + + val setEmission: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_emission".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission" } + } + } + + val setEmissionEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_emission_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_energy" } + } + } + + val setEmissionOperator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_emission_operator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_emission_operator" } + } + } + + val setFeature: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_feature".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_feature" } + } + } + + val setFlag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_flag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flag" } + } + } + + val setGrow: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_grow".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_grow" } + } + } + + val setGrowEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_grow_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_grow_enabled" } + } + } + + val setLineWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_line_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_line_width" } + } + } + + val setMetallic: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_metallic".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_metallic" } + } + } + + val setMetallicTextureChannel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_metallic_texture_channel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_metallic_texture_channel" } + } + } + + val setNormalScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_normal_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_normal_scale" } + } + } + + val setParticlesAnimHFrames: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_particles_anim_h_frames".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_particles_anim_h_frames" } + } + } + + val setParticlesAnimLoop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_particles_anim_loop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_particles_anim_loop" } + } + } + + val setParticlesAnimVFrames: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_particles_anim_v_frames".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_particles_anim_v_frames" } + } + } + + val setPointSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_point_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_point_size" } + } + } + + val setProximityFade: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_proximity_fade".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_proximity_fade" } + } + } + + val setProximityFadeDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_proximity_fade_distance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_proximity_fade_distance" } + } + } + + val setRefraction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_refraction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_refraction" } + } + } + + val setRefractionTextureChannel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_refraction_texture_channel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_refraction_texture_channel" + } + } + } + + val setRim: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_rim".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rim" } + } + } + + val setRimTint: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_rim_tint".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rim_tint" } + } + } + + val setRoughness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_roughness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_roughness" } + } + } + + val setRoughnessTextureChannel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_roughness_texture_channel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_roughness_texture_channel" + } + } + } + + val setSpecular: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_specular".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_specular" } + } + } + + val setSpecularMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_specular_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_specular_mode" } + } + } + + val setSubsurfaceScatteringStrength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_subsurface_scattering_strength".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_subsurface_scattering_strength" } + } + } + + val setTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture" } + } + } + + val setTransmission: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_transmission".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_transmission" } + } + } + + val setUv1Offset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_uv1_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_uv1_offset" } + } + } + + val setUv1Scale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_uv1_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_uv1_scale" } + } + } + + val setUv1TriplanarBlendSharpness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_uv1_triplanar_blend_sharpness".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_uv1_triplanar_blend_sharpness" } + } + } + + val setUv2Offset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_uv2_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_uv2_offset" } + } + } + + val setUv2Scale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_uv2_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_uv2_scale" } + } + } + + val setUv2TriplanarBlendSharpness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialMaterial".cstr.ptr, + "set_uv2_triplanar_blend_sharpness".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_uv2_triplanar_blend_sharpness" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/SpatialVelocityTracker.kt b/godot-kotlin/src/nativeGen/kotlin/godot/SpatialVelocityTracker.kt index 7b3ef419..a2efb2ff 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/SpatialVelocityTracker.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/SpatialVelocityTracker.kt @@ -100,40 +100,50 @@ open class SpatialVelocityTracker( * Container for method_bind pointers for SpatialVelocityTracker */ private object __method_bind { - val getTrackedLinearVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialVelocityTracker".cstr.ptr, - "get_tracked_linear_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tracked_linear_velocity" } - } - val isTrackingPhysicsStep: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialVelocityTracker".cstr.ptr, - "is_tracking_physics_step".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_tracking_physics_step" } - } - val reset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialVelocityTracker".cstr.ptr, - "reset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method reset" } - } - val setTrackPhysicsStep: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialVelocityTracker".cstr.ptr, - "set_track_physics_step".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_track_physics_step" } - } - val updatePosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialVelocityTracker".cstr.ptr, - "update_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method update_position" } - }} + val getTrackedLinearVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialVelocityTracker".cstr.ptr, + "get_tracked_linear_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tracked_linear_velocity" } + } + } + + val isTrackingPhysicsStep: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialVelocityTracker".cstr.ptr, + "is_tracking_physics_step".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_tracking_physics_step" } + } + } + + val reset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialVelocityTracker".cstr.ptr, + "reset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method reset" } + } + } + + val setTrackPhysicsStep: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialVelocityTracker".cstr.ptr, + "set_track_physics_step".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_track_physics_step" } + } + } + + val updatePosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpatialVelocityTracker".cstr.ptr, + "update_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method update_position" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/SphereMesh.kt b/godot-kotlin/src/nativeGen/kotlin/godot/SphereMesh.kt index f0aa092a..75daaf35 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/SphereMesh.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/SphereMesh.kt @@ -175,65 +175,95 @@ open class SphereMesh( * Container for method_bind pointers for SphereMesh */ private object __method_bind { - val getHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, - "get_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_height" } - } - val getIsHemisphere: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, - "get_is_hemisphere".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_is_hemisphere" } - } - val getRadialSegments: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, - "get_radial_segments".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_radial_segments" } - } - val getRadius: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, - "get_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_radius" } - } - val getRings: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, - "get_rings".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rings" } - } - val setHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, - "set_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_height" } - } - val setIsHemisphere: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, - "set_is_hemisphere".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_is_hemisphere" } - } - val setRadialSegments: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, - "set_radial_segments".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_radial_segments" } - } - val setRadius: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, - "set_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_radius" } - } - val setRings: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, - "set_rings".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rings" } - }} + val getHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, + "get_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_height" } + } + } + + val getIsHemisphere: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, + "get_is_hemisphere".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_is_hemisphere" } + } + } + + val getRadialSegments: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, + "get_radial_segments".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_radial_segments" } + } + } + + val getRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, + "get_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_radius" } + } + } + + val getRings: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, + "get_rings".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rings" } + } + } + + val setHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, + "set_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_height" } + } + } + + val setIsHemisphere: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, + "set_is_hemisphere".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_is_hemisphere" } + } + } + + val setRadialSegments: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, + "set_radial_segments".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_radial_segments" } + } + } + + val setRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, + "set_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_radius" } + } + } + + val setRings: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereMesh".cstr.ptr, + "set_rings".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rings" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/SphereShape.kt b/godot-kotlin/src/nativeGen/kotlin/godot/SphereShape.kt index 11df11f5..e8e0fe54 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/SphereShape.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/SphereShape.kt @@ -73,19 +73,23 @@ open class SphereShape( * Container for method_bind pointers for SphereShape */ private object __method_bind { - val getRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereShape".cstr.ptr, - "get_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_radius" } - } - val setRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereShape".cstr.ptr, - "set_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_radius" } - }} + val getRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereShape".cstr.ptr, + "get_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_radius" } + } + } + + val setRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SphereShape".cstr.ptr, + "set_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_radius" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/SpinBox.kt b/godot-kotlin/src/nativeGen/kotlin/godot/SpinBox.kt index a13f86ab..65230d39 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/SpinBox.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/SpinBox.kt @@ -186,65 +186,95 @@ open class SpinBox( * Container for method_bind pointers for SpinBox */ private object __method_bind { - val apply: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, - "apply".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method apply" } - } - val getAlign: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, - "get_align".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_align" } - } - val getLineEdit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, - "get_line_edit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_line_edit" } - } - val getPrefix: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, - "get_prefix".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_prefix" } - } - val getSuffix: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, - "get_suffix".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_suffix" } - } - val isEditable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, - "is_editable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_editable" } - } - val setAlign: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, - "set_align".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_align" } - } - val setEditable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, - "set_editable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_editable" } - } - val setPrefix: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, - "set_prefix".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_prefix" } - } - val setSuffix: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, - "set_suffix".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_suffix" } - }} + val apply: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, + "apply".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method apply" } + } + } + + val getAlign: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, + "get_align".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_align" } + } + } + + val getLineEdit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, + "get_line_edit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_line_edit" } + } + } + + val getPrefix: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, + "get_prefix".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_prefix" } + } + } + + val getSuffix: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, + "get_suffix".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_suffix" } + } + } + + val isEditable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, + "is_editable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_editable" } + } + } + + val setAlign: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, + "set_align".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_align" } + } + } + + val setEditable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, + "set_editable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_editable" } + } + } + + val setPrefix: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, + "set_prefix".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_prefix" } + } + } + + val setSuffix: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpinBox".cstr.ptr, + "set_suffix".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_suffix" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/SplitContainer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/SplitContainer.kt index aa963afb..6ae72038 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/SplitContainer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/SplitContainer.kt @@ -151,54 +151,68 @@ open class SplitContainer( * Container for method_bind pointers for SplitContainer */ private object __method_bind { - val clampSplitOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SplitContainer".cstr.ptr, - "clamp_split_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clamp_split_offset" } - } - val getDraggerVisibility: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SplitContainer".cstr.ptr, - "get_dragger_visibility".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_dragger_visibility" } - } - val getSplitOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SplitContainer".cstr.ptr, - "get_split_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_split_offset" } - } - val isCollapsed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SplitContainer".cstr.ptr, - "is_collapsed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_collapsed" } - } - val setCollapsed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SplitContainer".cstr.ptr, - "set_collapsed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collapsed" } - } - val setDraggerVisibility: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SplitContainer".cstr.ptr, - "set_dragger_visibility".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_dragger_visibility" } - } - val setSplitOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SplitContainer".cstr.ptr, - "set_split_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_split_offset" } - }} + val clampSplitOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SplitContainer".cstr.ptr, + "clamp_split_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clamp_split_offset" } + } + } + + val getDraggerVisibility: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SplitContainer".cstr.ptr, + "get_dragger_visibility".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_dragger_visibility" } + } + } + + val getSplitOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SplitContainer".cstr.ptr, + "get_split_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_split_offset" } + } + } + + val isCollapsed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SplitContainer".cstr.ptr, + "is_collapsed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_collapsed" } + } + } + + val setCollapsed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SplitContainer".cstr.ptr, + "set_collapsed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collapsed" } + } + } + + val setDraggerVisibility: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SplitContainer".cstr.ptr, + "set_dragger_visibility".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_dragger_visibility" } + } + } + + val setSplitOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SplitContainer".cstr.ptr, + "set_split_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_split_offset" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/SpringArm.kt b/godot-kotlin/src/nativeGen/kotlin/godot/SpringArm.kt index 334d45d4..b5f82642 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/SpringArm.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/SpringArm.kt @@ -187,77 +187,113 @@ open class SpringArm( * Container for method_bind pointers for SpringArm */ private object __method_bind { - val addExcludedObject: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, - "add_excluded_object".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_excluded_object" } - } - val clearExcludedObjects: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, - "clear_excluded_objects".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_excluded_objects" } - } - val getCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, - "get_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } - } - val getHitLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, - "get_hit_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_hit_length" } - } - val getLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, - "get_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_length" } - } - val getMargin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, - "get_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_margin" } - } - val getShape: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, - "get_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shape" } - } - val removeExcludedObject: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, - "remove_excluded_object".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_excluded_object" } - } - val setCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, - "set_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } - } - val setLength: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, - "set_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_length" } - } - val setMargin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, - "set_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_margin" } - } - val setShape: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, - "set_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shape" } - }} + val addExcludedObject: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, + "add_excluded_object".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_excluded_object" } + } + } + + val clearExcludedObjects: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, + "clear_excluded_objects".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_excluded_objects" } + } + } + + val getCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, + "get_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } + } + } + + val getHitLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, + "get_hit_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_hit_length" } + } + } + + val getLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, + "get_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_length" } + } + } + + val getMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, + "get_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_margin" } + } + } + + val getShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, + "get_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shape" } + } + } + + val removeExcludedObject: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, + "remove_excluded_object".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_excluded_object" } + } + } + + val setCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, + "set_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } + } + } + + val setLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, + "set_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_length" } + } + } + + val setMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, + "set_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_margin" } + } + } + + val setShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpringArm".cstr.ptr, + "set_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shape" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Sprite.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Sprite.kt index c12badbe..904bc4a3 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Sprite.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Sprite.kt @@ -446,173 +446,230 @@ open class Sprite( * Container for method_bind pointers for Sprite */ private object __method_bind { - val getFrame: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "get_frame".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_frame" } - } - val getFrameCoords: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "get_frame_coords".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_frame_coords" } - } - val getHframes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "get_hframes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_hframes" } - } - val getNormalMap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "get_normal_map".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_normal_map" } - } - val getOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "get_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_offset" } - } - val getRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "get_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rect" } - } - val getRegionRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "get_region_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_region_rect" } - } - val getTexture: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "get_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture" } - } - val getVframes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "get_vframes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vframes" } - } - val isCentered: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "is_centered".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_centered" } - } - val isFlippedH: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "is_flipped_h".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_flipped_h" } - } - val isFlippedV: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "is_flipped_v".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_flipped_v" } - } - val isPixelOpaque: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "is_pixel_opaque".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_pixel_opaque" } - } - val isRegion: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "is_region".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_region" } - } - val isRegionFilterClipEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "is_region_filter_clip_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_region_filter_clip_enabled" } - } - val setCentered: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "set_centered".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_centered" } - } - val setFlipH: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "set_flip_h".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flip_h" } - } - val setFlipV: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "set_flip_v".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flip_v" } - } - val setFrame: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "set_frame".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_frame" } - } - val setFrameCoords: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "set_frame_coords".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_frame_coords" } - } - val setHframes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "set_hframes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_hframes" } - } - val setNormalMap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "set_normal_map".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_normal_map" } - } - val setOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "set_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_offset" } - } - val setRegion: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "set_region".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_region" } - } - val setRegionFilterClip: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "set_region_filter_clip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_region_filter_clip" } - } - val setRegionRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "set_region_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_region_rect" } - } - val setTexture: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "set_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture" } - } - val setVframes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, - "set_vframes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_vframes" } - }} + val getFrame: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "get_frame".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_frame" } + } + } + + val getFrameCoords: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "get_frame_coords".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_frame_coords" } + } + } + + val getHframes: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "get_hframes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_hframes" } + } + } + + val getNormalMap: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "get_normal_map".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_normal_map" } + } + } + + val getOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "get_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_offset" } + } + } + + val getRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "get_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rect" } + } + } + + val getRegionRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "get_region_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_region_rect" } + } + } + + val getTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "get_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture" } + } + } + + val getVframes: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "get_vframes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vframes" } + } + } + + val isCentered: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "is_centered".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_centered" } + } + } + + val isFlippedH: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "is_flipped_h".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_flipped_h" } + } + } + + val isFlippedV: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "is_flipped_v".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_flipped_v" } + } + } + + val isPixelOpaque: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "is_pixel_opaque".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_pixel_opaque" } + } + } + + val isRegion: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "is_region".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_region" } + } + } + + val isRegionFilterClipEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "is_region_filter_clip_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_region_filter_clip_enabled" + } + } + } + + val setCentered: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "set_centered".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_centered" } + } + } + + val setFlipH: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "set_flip_h".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flip_h" } + } + } + + val setFlipV: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "set_flip_v".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flip_v" } + } + } + + val setFrame: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "set_frame".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_frame" } + } + } + + val setFrameCoords: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "set_frame_coords".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_frame_coords" } + } + } + + val setHframes: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "set_hframes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_hframes" } + } + } + + val setNormalMap: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "set_normal_map".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_normal_map" } + } + } + + val setOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "set_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_offset" } + } + } + + val setRegion: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "set_region".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_region" } + } + } + + val setRegionFilterClip: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "set_region_filter_clip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_region_filter_clip" } + } + } + + val setRegionRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "set_region_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_region_rect" } + } + } + + val setTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "set_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture" } + } + } + + val setVframes: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite".cstr.ptr, + "set_vframes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_vframes" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Sprite3D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Sprite3D.kt index c0fe81f9..a8fc4c54 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Sprite3D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Sprite3D.kt @@ -254,89 +254,131 @@ open class Sprite3D( * Container for method_bind pointers for Sprite3D */ private object __method_bind { - val getFrame: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, - "get_frame".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_frame" } - } - val getFrameCoords: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, - "get_frame_coords".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_frame_coords" } - } - val getHframes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, - "get_hframes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_hframes" } - } - val getRegionRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, - "get_region_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_region_rect" } - } - val getTexture: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, - "get_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture" } - } - val getVframes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, - "get_vframes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vframes" } - } - val isRegion: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, - "is_region".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_region" } - } - val setFrame: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, - "set_frame".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_frame" } - } - val setFrameCoords: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, - "set_frame_coords".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_frame_coords" } - } - val setHframes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, - "set_hframes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_hframes" } - } - val setRegion: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, - "set_region".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_region" } - } - val setRegionRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, - "set_region_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_region_rect" } - } - val setTexture: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, - "set_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture" } - } - val setVframes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, - "set_vframes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_vframes" } - }} + val getFrame: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, + "get_frame".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_frame" } + } + } + + val getFrameCoords: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, + "get_frame_coords".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_frame_coords" } + } + } + + val getHframes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, + "get_hframes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_hframes" } + } + } + + val getRegionRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, + "get_region_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_region_rect" } + } + } + + val getTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, + "get_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture" } + } + } + + val getVframes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, + "get_vframes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vframes" } + } + } + + val isRegion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, + "is_region".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_region" } + } + } + + val setFrame: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, + "set_frame".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_frame" } + } + } + + val setFrameCoords: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, + "set_frame_coords".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_frame_coords" } + } + } + + val setHframes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, + "set_hframes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_hframes" } + } + } + + val setRegion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, + "set_region".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_region" } + } + } + + val setRegionRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, + "set_region_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_region_rect" } + } + } + + val setTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, + "set_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture" } + } + } + + val setVframes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Sprite3D".cstr.ptr, + "set_vframes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_vframes" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/SpriteBase3D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/SpriteBase3D.kt index d3454fe2..a730814b 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/SpriteBase3D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/SpriteBase3D.kt @@ -438,173 +438,221 @@ open class SpriteBase3D( * Container for method_bind pointers for SpriteBase3D */ private object __method_bind { - val generateTriangleMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "generate_triangle_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method generate_triangle_mesh" } - } - val getAlphaCutMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "get_alpha_cut_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_alpha_cut_mode" } - } - val getAxis: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "get_axis".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_axis" } - } - val getBillboardMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "get_billboard_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_billboard_mode" } - } - val getDrawFlag: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "get_draw_flag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_draw_flag" } - } - val getItemRect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "get_item_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_rect" } - } - val getModulate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "get_modulate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_modulate" } - } - val getOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "get_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_offset" } - } - val getOpacity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "get_opacity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_opacity" } - } - val getPixelSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "get_pixel_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pixel_size" } - } - val isCentered: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "is_centered".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_centered" } - } - val isFlippedH: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "is_flipped_h".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_flipped_h" } - } - val isFlippedV: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "is_flipped_v".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_flipped_v" } - } - val setAlphaCutMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "set_alpha_cut_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_alpha_cut_mode" } - } - val setAxis: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "set_axis".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_axis" } - } - val setBillboardMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "set_billboard_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_billboard_mode" } - } - val setCentered: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "set_centered".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_centered" } - } - val setDrawFlag: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "set_draw_flag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_draw_flag" } - } - val setFlipH: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "set_flip_h".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flip_h" } - } - val setFlipV: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "set_flip_v".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flip_v" } - } - val setModulate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "set_modulate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_modulate" } - } - val setOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "set_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_offset" } - } - val setOpacity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "set_opacity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_opacity" } - } - val setPixelSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, - "set_pixel_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pixel_size" } - }} + val generateTriangleMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "generate_triangle_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method generate_triangle_mesh" } + } + } + + val getAlphaCutMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "get_alpha_cut_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_alpha_cut_mode" } + } + } + + val getAxis: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "get_axis".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_axis" } + } + } + + val getBillboardMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "get_billboard_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_billboard_mode" } + } + } + + val getDrawFlag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "get_draw_flag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_draw_flag" } + } + } + + val getItemRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "get_item_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_rect" } + } + } + + val getModulate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "get_modulate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_modulate" } + } + } + + val getOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "get_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_offset" } + } + } + + val getOpacity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "get_opacity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_opacity" } + } + } + + val getPixelSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "get_pixel_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pixel_size" } + } + } + + val isCentered: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "is_centered".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_centered" } + } + } + + val isFlippedH: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "is_flipped_h".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_flipped_h" } + } + } + + val isFlippedV: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "is_flipped_v".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_flipped_v" } + } + } + + val setAlphaCutMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "set_alpha_cut_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_alpha_cut_mode" } + } + } + + val setAxis: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "set_axis".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_axis" } + } + } + + val setBillboardMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "set_billboard_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_billboard_mode" } + } + } + + val setCentered: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "set_centered".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_centered" } + } + } + + val setDrawFlag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "set_draw_flag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_draw_flag" } + } + } + + val setFlipH: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "set_flip_h".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flip_h" } + } + } + + val setFlipV: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "set_flip_v".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flip_v" } + } + } + + val setModulate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "set_modulate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_modulate" } + } + } + + val setOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "set_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_offset" } + } + } + + val setOpacity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "set_opacity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_opacity" } + } + } + + val setPixelSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteBase3D".cstr.ptr, + "set_pixel_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pixel_size" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/SpriteFrames.kt b/godot-kotlin/src/nativeGen/kotlin/godot/SpriteFrames.kt index 0fd7e695..4c5a034d 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/SpriteFrames.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/SpriteFrames.kt @@ -231,117 +231,149 @@ open class SpriteFrames( * Container for method_bind pointers for SpriteFrames */ private object __method_bind { - val addAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, - "add_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_animation" } - } - val addFrame: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, - "add_frame".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_frame" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val clearAll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, - "clear_all".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_all" } - } - val getAnimationLoop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, - "get_animation_loop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_animation_loop" } - } - val getAnimationNames: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, - "get_animation_names".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_animation_names" } - } - val getAnimationSpeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, - "get_animation_speed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_animation_speed" } - } - val getFrame: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, - "get_frame".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_frame" } - } - val getFrameCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, - "get_frame_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_frame_count" } - } - val hasAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, - "has_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_animation" } - } - val removeAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, - "remove_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_animation" } - } - val removeFrame: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, - "remove_frame".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_frame" } - } - val renameAnimation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, - "rename_animation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rename_animation" } - } - val setAnimationLoop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, - "set_animation_loop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_animation_loop" } - } - val setAnimationSpeed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, - "set_animation_speed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_animation_speed" } - } - val setFrame: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, - "set_frame".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_frame" } - }} + val addAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, + "add_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_animation" } + } + } + + val addFrame: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, + "add_frame".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_frame" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val clearAll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, + "clear_all".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_all" } + } + } + + val getAnimationLoop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, + "get_animation_loop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_animation_loop" } + } + } + + val getAnimationNames: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, + "get_animation_names".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_animation_names" } + } + } + + val getAnimationSpeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, + "get_animation_speed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_animation_speed" } + } + } + + val getFrame: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, + "get_frame".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_frame" } + } + } + + val getFrameCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, + "get_frame_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_frame_count" } + } + } + + val hasAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, + "has_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_animation" } + } + } + + val removeAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, + "remove_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_animation" } + } + } + + val removeFrame: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, + "remove_frame".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_frame" } + } + } + + val renameAnimation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, + "rename_animation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rename_animation" } + } + } + + val setAnimationLoop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, + "set_animation_loop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_animation_loop" } + } + } + + val setAnimationSpeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, + "set_animation_speed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_animation_speed" } + } + } + + val setFrame: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SpriteFrames".cstr.ptr, + "set_frame".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_frame" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/StaticBody.kt b/godot-kotlin/src/nativeGen/kotlin/godot/StaticBody.kt index 9e10553d..ec3bbc72 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/StaticBody.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/StaticBody.kt @@ -202,65 +202,99 @@ open class StaticBody( * Container for method_bind pointers for StaticBody */ private object __method_bind { - val getBounce: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, - "get_bounce".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bounce" } - } - val getConstantAngularVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, - "get_constant_angular_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_constant_angular_velocity" } - } - val getConstantLinearVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, - "get_constant_linear_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_constant_linear_velocity" } - } - val getFriction: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, - "get_friction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_friction" } - } - val getPhysicsMaterialOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, - "get_physics_material_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_physics_material_override" } - } - val setBounce: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, - "set_bounce".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bounce" } - } - val setConstantAngularVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, - "set_constant_angular_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_constant_angular_velocity" } - } - val setConstantLinearVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, - "set_constant_linear_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_constant_linear_velocity" } - } - val setFriction: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, - "set_friction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_friction" } - } - val setPhysicsMaterialOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, - "set_physics_material_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_physics_material_override" } - }} + val getBounce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, + "get_bounce".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bounce" } + } + } + + val getConstantAngularVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, + "get_constant_angular_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_constant_angular_velocity" + } + } + } + + val getConstantLinearVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, + "get_constant_linear_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_constant_linear_velocity" } + } + } + + val getFriction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, + "get_friction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_friction" } + } + } + + val getPhysicsMaterialOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, + "get_physics_material_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_physics_material_override" + } + } + } + + val setBounce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, + "set_bounce".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bounce" } + } + } + + val setConstantAngularVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, + "set_constant_angular_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_constant_angular_velocity" + } + } + } + + val setConstantLinearVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, + "set_constant_linear_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_constant_linear_velocity" } + } + } + + val setFriction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, + "set_friction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_friction" } + } + } + + val setPhysicsMaterialOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody".cstr.ptr, + "set_physics_material_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_physics_material_override" + } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/StaticBody2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/StaticBody2D.kt index 57c4ccff..bfb15503 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/StaticBody2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/StaticBody2D.kt @@ -192,75 +192,99 @@ open class StaticBody2D( * Container for method_bind pointers for StaticBody2D */ private object __method_bind { - val getBounce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, - "get_bounce".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bounce" } - } - val getConstantAngularVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, - "get_constant_angular_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_constant_angular_velocity" } - } - val getConstantLinearVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, - "get_constant_linear_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_constant_linear_velocity" } - } - val getFriction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, - "get_friction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_friction" } - } - val getPhysicsMaterialOverride: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, - "get_physics_material_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_physics_material_override" } - } - val setBounce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, - "set_bounce".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bounce" } - } - val setConstantAngularVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, - "set_constant_angular_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_constant_angular_velocity" } - } - val setConstantLinearVelocity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, - "set_constant_linear_velocity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_constant_linear_velocity" } - } - val setFriction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, - "set_friction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_friction" } - } - val setPhysicsMaterialOverride: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, - "set_physics_material_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_physics_material_override" } - }} + val getBounce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, + "get_bounce".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bounce" } + } + } + + val getConstantAngularVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, + "get_constant_angular_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_constant_angular_velocity" + } + } + } + + val getConstantLinearVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, + "get_constant_linear_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_constant_linear_velocity" } + } + } + + val getFriction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, + "get_friction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_friction" } + } + } + + val getPhysicsMaterialOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, + "get_physics_material_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_physics_material_override" + } + } + } + + val setBounce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, + "set_bounce".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bounce" } + } + } + + val setConstantAngularVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, + "set_constant_angular_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_constant_angular_velocity" + } + } + } + + val setConstantLinearVelocity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, + "set_constant_linear_velocity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_constant_linear_velocity" } + } + } + + val setFriction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, + "set_friction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_friction" } + } + } + + val setPhysicsMaterialOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StaticBody2D".cstr.ptr, + "set_physics_material_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_physics_material_override" + } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/StreamPeer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/StreamPeer.kt index 4bd53cda..aa467847 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/StreamPeer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/StreamPeer.kt @@ -351,203 +351,302 @@ open class StreamPeer( * Container for method_bind pointers for StreamPeer */ private object __method_bind { - val get16: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "get_16".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_16" } - } - val get32: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "get_32".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_32" } - } - val get64: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "get_64".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_64" } - } - val get8: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "get_8".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_8" } - } - val getAvailableBytes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "get_available_bytes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_available_bytes" } - } - val getData: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "get_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_data" } - } - val getDouble: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "get_double".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_double" } - } - val getFloat: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "get_float".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_float" } - } - val getPartialData: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "get_partial_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_partial_data" } - } - val getString: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "get_string".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_string" } - } - val getU16: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "get_u16".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_u16" } - } - val getU32: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "get_u32".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_u32" } - } - val getU64: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "get_u64".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_u64" } - } - val getU8: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "get_u8".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_u8" } - } - val getUtf8String: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "get_utf8_string".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_utf8_string" } - } - val getVar: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "get_var".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_var" } - } - val isBigEndianEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "is_big_endian_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_big_endian_enabled" } - } - val put16: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "put_16".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method put_16" } - } - val put32: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "put_32".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method put_32" } - } - val put64: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "put_64".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method put_64" } - } - val put8: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "put_8".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method put_8" } - } - val putData: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "put_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method put_data" } - } - val putDouble: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "put_double".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method put_double" } - } - val putFloat: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "put_float".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method put_float" } - } - val putPartialData: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "put_partial_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method put_partial_data" } - } - val putString: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "put_string".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method put_string" } - } - val putU16: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "put_u16".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method put_u16" } - } - val putU32: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "put_u32".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method put_u32" } - } - val putU64: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "put_u64".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method put_u64" } - } - val putU8: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "put_u8".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method put_u8" } - } - val putUtf8String: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "put_utf8_string".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method put_utf8_string" } - } - val putVar: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "put_var".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method put_var" } - } - val setBigEndian: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, - "set_big_endian".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_big_endian" } - }} + val get16: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "get_16".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_16" } + } + } + + val get32: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "get_32".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_32" } + } + } + + val get64: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "get_64".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_64" } + } + } + + val get8: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "get_8".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_8" } + } + } + + val getAvailableBytes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "get_available_bytes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_available_bytes" } + } + } + + val getData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "get_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_data" } + } + } + + val getDouble: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "get_double".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_double" } + } + } + + val getFloat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "get_float".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_float" } + } + } + + val getPartialData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "get_partial_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_partial_data" } + } + } + + val getString: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "get_string".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_string" } + } + } + + val getU16: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "get_u16".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_u16" } + } + } + + val getU32: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "get_u32".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_u32" } + } + } + + val getU64: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "get_u64".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_u64" } + } + } + + val getU8: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "get_u8".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_u8" } + } + } + + val getUtf8String: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "get_utf8_string".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_utf8_string" } + } + } + + val getVar: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "get_var".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_var" } + } + } + + val isBigEndianEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "is_big_endian_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_big_endian_enabled" } + } + } + + val put16: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "put_16".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method put_16" } + } + } + + val put32: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "put_32".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method put_32" } + } + } + + val put64: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "put_64".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method put_64" } + } + } + + val put8: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "put_8".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method put_8" } + } + } + + val putData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "put_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method put_data" } + } + } + + val putDouble: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "put_double".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method put_double" } + } + } + + val putFloat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "put_float".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method put_float" } + } + } + + val putPartialData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "put_partial_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method put_partial_data" } + } + } + + val putString: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "put_string".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method put_string" } + } + } + + val putU16: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "put_u16".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method put_u16" } + } + } + + val putU32: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "put_u32".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method put_u32" } + } + } + + val putU64: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "put_u64".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method put_u64" } + } + } + + val putU8: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "put_u8".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method put_u8" } + } + } + + val putUtf8String: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "put_utf8_string".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method put_utf8_string" } + } + } + + val putVar: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "put_var".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method put_var" } + } + } + + val setBigEndian: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeer".cstr.ptr, + "set_big_endian".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_big_endian" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/StreamPeerBuffer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/StreamPeerBuffer.kt index cb64faaf..f0c974a7 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/StreamPeerBuffer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/StreamPeerBuffer.kt @@ -139,61 +139,77 @@ open class StreamPeerBuffer( * Container for method_bind pointers for StreamPeerBuffer */ private object __method_bind { - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerBuffer".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val duplicate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerBuffer".cstr.ptr, - "duplicate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method duplicate" } - } - val getDataArray: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerBuffer".cstr.ptr, - "get_data_array".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_data_array" } - } - val getPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerBuffer".cstr.ptr, - "get_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_position" } - } - val getSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerBuffer".cstr.ptr, - "get_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_size" } - } - val resize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerBuffer".cstr.ptr, - "resize".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method resize" } - } - val seek: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerBuffer".cstr.ptr, - "seek".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method seek" } - } - val setDataArray: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerBuffer".cstr.ptr, - "set_data_array".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_data_array" } - }} + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerBuffer".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val duplicate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerBuffer".cstr.ptr, + "duplicate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method duplicate" } + } + } + + val getDataArray: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerBuffer".cstr.ptr, + "get_data_array".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_data_array" } + } + } + + val getPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerBuffer".cstr.ptr, + "get_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_position" } + } + } + + val getSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerBuffer".cstr.ptr, + "get_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_size" } + } + } + + val resize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerBuffer".cstr.ptr, + "resize".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method resize" } + } + } + + val seek: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerBuffer".cstr.ptr, + "seek".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method seek" } + } + } + + val setDataArray: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerBuffer".cstr.ptr, + "set_data_array".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_data_array" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/StreamPeerSSL.kt b/godot-kotlin/src/nativeGen/kotlin/godot/StreamPeerSSL.kt index c6b2a60a..cb3c1b22 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/StreamPeerSSL.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/StreamPeerSSL.kt @@ -164,54 +164,70 @@ open class StreamPeerSSL( * Container for method_bind pointers for StreamPeerSSL */ private object __method_bind { - val acceptStream: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerSSL".cstr.ptr, - "accept_stream".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method accept_stream" } - } - val connectToStream: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerSSL".cstr.ptr, - "connect_to_stream".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method connect_to_stream" } - } - val disconnectFromStream: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerSSL".cstr.ptr, - "disconnect_from_stream".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method disconnect_from_stream" } - } - val getStatus: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerSSL".cstr.ptr, - "get_status".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_status" } - } - val isBlockingHandshakeEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerSSL".cstr.ptr, - "is_blocking_handshake_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_blocking_handshake_enabled" } - } - val poll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerSSL".cstr.ptr, - "poll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method poll" } - } - val setBlockingHandshakeEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerSSL".cstr.ptr, - "set_blocking_handshake_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_blocking_handshake_enabled" } - }} + val acceptStream: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerSSL".cstr.ptr, + "accept_stream".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method accept_stream" } + } + } + + val connectToStream: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerSSL".cstr.ptr, + "connect_to_stream".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method connect_to_stream" } + } + } + + val disconnectFromStream: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerSSL".cstr.ptr, + "disconnect_from_stream".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method disconnect_from_stream" } + } + } + + val getStatus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerSSL".cstr.ptr, + "get_status".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_status" } + } + } + + val isBlockingHandshakeEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerSSL".cstr.ptr, + "is_blocking_handshake_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_blocking_handshake_enabled" + } + } + } + + val poll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerSSL".cstr.ptr, + "poll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method poll" } + } + } + + val setBlockingHandshakeEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerSSL".cstr.ptr, + "set_blocking_handshake_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_blocking_handshake_enabled" + } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/StreamPeerTCP.kt b/godot-kotlin/src/nativeGen/kotlin/godot/StreamPeerTCP.kt index 38b64fb7..0c592ca1 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/StreamPeerTCP.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/StreamPeerTCP.kt @@ -141,54 +141,68 @@ open class StreamPeerTCP( * Container for method_bind pointers for StreamPeerTCP */ private object __method_bind { - val connectToHost: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerTCP".cstr.ptr, - "connect_to_host".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method connect_to_host" } - } - val disconnectFromHost: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerTCP".cstr.ptr, - "disconnect_from_host".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method disconnect_from_host" } - } - val getConnectedHost: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerTCP".cstr.ptr, - "get_connected_host".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connected_host" } - } - val getConnectedPort: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerTCP".cstr.ptr, - "get_connected_port".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connected_port" } - } - val getStatus: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerTCP".cstr.ptr, - "get_status".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_status" } - } - val isConnectedToHost: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerTCP".cstr.ptr, - "is_connected_to_host".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_connected_to_host" } - } - val setNoDelay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerTCP".cstr.ptr, - "set_no_delay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_no_delay" } - }} + val connectToHost: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerTCP".cstr.ptr, + "connect_to_host".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method connect_to_host" } + } + } + + val disconnectFromHost: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerTCP".cstr.ptr, + "disconnect_from_host".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method disconnect_from_host" } + } + } + + val getConnectedHost: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerTCP".cstr.ptr, + "get_connected_host".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connected_host" } + } + } + + val getConnectedPort: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerTCP".cstr.ptr, + "get_connected_port".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connected_port" } + } + } + + val getStatus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerTCP".cstr.ptr, + "get_status".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_status" } + } + } + + val isConnectedToHost: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerTCP".cstr.ptr, + "is_connected_to_host".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_connected_to_host" } + } + } + + val setNoDelay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamPeerTCP".cstr.ptr, + "set_no_delay".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_no_delay" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/StreamTexture.kt b/godot-kotlin/src/nativeGen/kotlin/godot/StreamTexture.kt index 2187a43b..12611384 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/StreamTexture.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/StreamTexture.kt @@ -77,19 +77,23 @@ open class StreamTexture( * Container for method_bind pointers for StreamTexture */ private object __method_bind { - val getLoadPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamTexture".cstr.ptr, - "get_load_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_load_path" } - } - val load: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamTexture".cstr.ptr, - "load".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method load" } - }} + val getLoadPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamTexture".cstr.ptr, + "get_load_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_load_path" } + } + } + + val load: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StreamTexture".cstr.ptr, + "load".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method load" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/StyleBox.kt b/godot-kotlin/src/nativeGen/kotlin/godot/StyleBox.kt index 9c26f0a1..0b6a3beb 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/StyleBox.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/StyleBox.kt @@ -177,59 +177,86 @@ open class StyleBox( * Container for method_bind pointers for StyleBox */ private object __method_bind { - val draw: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBox".cstr.ptr, - "draw".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw" } - } - val getCenterSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBox".cstr.ptr, - "get_center_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_center_size" } - } - val getCurrentItemDrawn: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBox".cstr.ptr, - "get_current_item_drawn".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_item_drawn" } - } - val getDefaultMargin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBox".cstr.ptr, - "get_default_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_default_margin" } - } - val getMargin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBox".cstr.ptr, - "get_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_margin" } - } - val getMinimumSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBox".cstr.ptr, - "get_minimum_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_minimum_size" } - } - val getOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBox".cstr.ptr, - "get_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_offset" } - } - val setDefaultMargin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBox".cstr.ptr, - "set_default_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_default_margin" } - } - val testMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBox".cstr.ptr, - "test_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method test_mask" } - }} + val draw: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBox".cstr.ptr, + "draw".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw" } + } + } + + val getCenterSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBox".cstr.ptr, + "get_center_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_center_size" } + } + } + + val getCurrentItemDrawn: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBox".cstr.ptr, + "get_current_item_drawn".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_item_drawn" } + } + } + + val getDefaultMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBox".cstr.ptr, + "get_default_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_default_margin" } + } + } + + val getMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBox".cstr.ptr, + "get_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_margin" } + } + } + + val getMinimumSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBox".cstr.ptr, + "get_minimum_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_minimum_size" } + } + } + + val getOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBox".cstr.ptr, + "get_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_offset" } + } + } + + val setDefaultMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBox".cstr.ptr, + "set_default_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_default_margin" } + } + } + + val testMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBox".cstr.ptr, + "test_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method test_mask" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/StyleBoxFlat.kt b/godot-kotlin/src/nativeGen/kotlin/godot/StyleBoxFlat.kt index edf3cc38..c5a94eec 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/StyleBoxFlat.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/StyleBoxFlat.kt @@ -564,229 +564,293 @@ open class StyleBoxFlat( * Container for method_bind pointers for StyleBoxFlat */ private object __method_bind { - val getAaSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "get_aa_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_aa_size" } - } - val getBgColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "get_bg_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bg_color" } - } - val getBorderBlend: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "get_border_blend".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_border_blend" } - } - val getBorderColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "get_border_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_border_color" } - } - val getBorderWidth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "get_border_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_border_width" } - } - val getBorderWidthMin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "get_border_width_min".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_border_width_min" } - } - val getCornerDetail: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "get_corner_detail".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_corner_detail" } - } - val getCornerRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "get_corner_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_corner_radius" } - } - val getExpandMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "get_expand_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_expand_margin" } - } - val getShadowColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "get_shadow_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shadow_color" } - } - val getShadowOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "get_shadow_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shadow_offset" } - } - val getShadowSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "get_shadow_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shadow_size" } - } - val isAntiAliased: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "is_anti_aliased".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_anti_aliased" } - } - val isDrawCenterEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "is_draw_center_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_draw_center_enabled" } - } - val setAaSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "set_aa_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_aa_size" } - } - val setAntiAliased: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "set_anti_aliased".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_anti_aliased" } - } - val setBgColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "set_bg_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bg_color" } - } - val setBorderBlend: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "set_border_blend".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_border_blend" } - } - val setBorderColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "set_border_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_border_color" } - } - val setBorderWidth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "set_border_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_border_width" } - } - val setBorderWidthAll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "set_border_width_all".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_border_width_all" } - } - val setCornerDetail: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "set_corner_detail".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_corner_detail" } - } - val setCornerRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "set_corner_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_corner_radius" } - } - val setCornerRadiusAll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "set_corner_radius_all".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_corner_radius_all" } - } - val setCornerRadiusIndividual: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "set_corner_radius_individual".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_corner_radius_individual" } - } - val setDrawCenter: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "set_draw_center".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_draw_center" } - } - val setExpandMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "set_expand_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_expand_margin" } - } - val setExpandMarginAll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "set_expand_margin_all".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_expand_margin_all" } - } - val setExpandMarginIndividual: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "set_expand_margin_individual".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_expand_margin_individual" } - } - val setShadowColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "set_shadow_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shadow_color" } - } - val setShadowOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "set_shadow_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shadow_offset" } - } - val setShadowSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, - "set_shadow_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shadow_size" } - }} + val getAaSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "get_aa_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_aa_size" } + } + } + + val getBgColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "get_bg_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bg_color" } + } + } + + val getBorderBlend: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "get_border_blend".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_border_blend" } + } + } + + val getBorderColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "get_border_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_border_color" } + } + } + + val getBorderWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "get_border_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_border_width" } + } + } + + val getBorderWidthMin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "get_border_width_min".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_border_width_min" } + } + } + + val getCornerDetail: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "get_corner_detail".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_corner_detail" } + } + } + + val getCornerRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "get_corner_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_corner_radius" } + } + } + + val getExpandMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "get_expand_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_expand_margin" } + } + } + + val getShadowColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "get_shadow_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shadow_color" } + } + } + + val getShadowOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "get_shadow_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shadow_offset" } + } + } + + val getShadowSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "get_shadow_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shadow_size" } + } + } + + val isAntiAliased: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "is_anti_aliased".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_anti_aliased" } + } + } + + val isDrawCenterEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "is_draw_center_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_draw_center_enabled" } + } + } + + val setAaSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "set_aa_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_aa_size" } + } + } + + val setAntiAliased: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "set_anti_aliased".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_anti_aliased" } + } + } + + val setBgColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "set_bg_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bg_color" } + } + } + + val setBorderBlend: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "set_border_blend".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_border_blend" } + } + } + + val setBorderColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "set_border_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_border_color" } + } + } + + val setBorderWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "set_border_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_border_width" } + } + } + + val setBorderWidthAll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "set_border_width_all".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_border_width_all" } + } + } + + val setCornerDetail: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "set_corner_detail".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_corner_detail" } + } + } + + val setCornerRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "set_corner_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_corner_radius" } + } + } + + val setCornerRadiusAll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "set_corner_radius_all".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_corner_radius_all" } + } + } + + val setCornerRadiusIndividual: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "set_corner_radius_individual".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_corner_radius_individual" } + } + } + + val setDrawCenter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "set_draw_center".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_draw_center" } + } + } + + val setExpandMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "set_expand_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_expand_margin" } + } + } + + val setExpandMarginAll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "set_expand_margin_all".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_expand_margin_all" } + } + } + + val setExpandMarginIndividual: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "set_expand_margin_individual".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_expand_margin_individual" } + } + } + + val setShadowColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "set_shadow_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shadow_color" } + } + } + + val setShadowOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "set_shadow_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shadow_offset" } + } + } + + val setShadowSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxFlat".cstr.ptr, + "set_shadow_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shadow_size" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/StyleBoxLine.kt b/godot-kotlin/src/nativeGen/kotlin/godot/StyleBoxLine.kt index e14ff911..ead0ffc4 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/StyleBoxLine.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/StyleBoxLine.kt @@ -187,75 +187,95 @@ open class StyleBoxLine( * Container for method_bind pointers for StyleBoxLine */ private object __method_bind { - val getColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, - "get_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_color" } - } - val getGrowBegin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, - "get_grow_begin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_grow_begin" } - } - val getGrowEnd: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, - "get_grow_end".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_grow_end" } - } - val getThickness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, - "get_thickness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_thickness" } - } - val isVertical: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, - "is_vertical".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_vertical" } - } - val setColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, - "set_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_color" } - } - val setGrowBegin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, - "set_grow_begin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_grow_begin" } - } - val setGrowEnd: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, - "set_grow_end".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_grow_end" } - } - val setThickness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, - "set_thickness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_thickness" } - } - val setVertical: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, - "set_vertical".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_vertical" } - }} + val getColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, + "get_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_color" } + } + } + + val getGrowBegin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, + "get_grow_begin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_grow_begin" } + } + } + + val getGrowEnd: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, + "get_grow_end".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_grow_end" } + } + } + + val getThickness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, + "get_thickness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_thickness" } + } + } + + val isVertical: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, + "is_vertical".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_vertical" } + } + } + + val setColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, + "set_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_color" } + } + } + + val setGrowBegin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, + "set_grow_begin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_grow_begin" } + } + } + + val setGrowEnd: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, + "set_grow_end".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_grow_end" } + } + } + + val setThickness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, + "set_thickness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_thickness" } + } + } + + val setVertical: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxLine".cstr.ptr, + "set_vertical".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_vertical" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/StyleBoxTexture.kt b/godot-kotlin/src/nativeGen/kotlin/godot/StyleBoxTexture.kt index 953faf8d..8b638b0b 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/StyleBoxTexture.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/StyleBoxTexture.kt @@ -407,145 +407,185 @@ open class StyleBoxTexture( * Container for method_bind pointers for StyleBoxTexture */ private object __method_bind { - val getExpandMarginSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "get_expand_margin_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_expand_margin_size" } - } - val getHAxisStretchMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "get_h_axis_stretch_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_h_axis_stretch_mode" } - } - val getMarginSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "get_margin_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_margin_size" } - } - val getModulate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "get_modulate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_modulate" } - } - val getNormalMap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "get_normal_map".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_normal_map" } - } - val getRegionRect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "get_region_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_region_rect" } - } - val getTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "get_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture" } - } - val getVAxisStretchMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "get_v_axis_stretch_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_v_axis_stretch_mode" } - } - val isDrawCenterEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "is_draw_center_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_draw_center_enabled" } - } - val setDrawCenter: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "set_draw_center".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_draw_center" } - } - val setExpandMarginAll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "set_expand_margin_all".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_expand_margin_all" } - } - val setExpandMarginIndividual: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "set_expand_margin_individual".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_expand_margin_individual" } - } - val setExpandMarginSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "set_expand_margin_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_expand_margin_size" } - } - val setHAxisStretchMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "set_h_axis_stretch_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_h_axis_stretch_mode" } - } - val setMarginSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "set_margin_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_margin_size" } - } - val setModulate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "set_modulate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_modulate" } - } - val setNormalMap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "set_normal_map".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_normal_map" } - } - val setRegionRect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "set_region_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_region_rect" } - } - val setTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "set_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture" } - } - val setVAxisStretchMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, - "set_v_axis_stretch_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_v_axis_stretch_mode" } - }} + val getExpandMarginSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "get_expand_margin_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_expand_margin_size" } + } + } + + val getHAxisStretchMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "get_h_axis_stretch_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_h_axis_stretch_mode" } + } + } + + val getMarginSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "get_margin_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_margin_size" } + } + } + + val getModulate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "get_modulate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_modulate" } + } + } + + val getNormalMap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "get_normal_map".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_normal_map" } + } + } + + val getRegionRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "get_region_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_region_rect" } + } + } + + val getTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "get_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture" } + } + } + + val getVAxisStretchMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "get_v_axis_stretch_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_v_axis_stretch_mode" } + } + } + + val isDrawCenterEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "is_draw_center_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_draw_center_enabled" } + } + } + + val setDrawCenter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "set_draw_center".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_draw_center" } + } + } + + val setExpandMarginAll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "set_expand_margin_all".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_expand_margin_all" } + } + } + + val setExpandMarginIndividual: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "set_expand_margin_individual".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_expand_margin_individual" } + } + } + + val setExpandMarginSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "set_expand_margin_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_expand_margin_size" } + } + } + + val setHAxisStretchMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "set_h_axis_stretch_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_h_axis_stretch_mode" } + } + } + + val setMarginSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "set_margin_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_margin_size" } + } + } + + val setModulate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "set_modulate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_modulate" } + } + } + + val setNormalMap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "set_normal_map".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_normal_map" } + } + } + + val setRegionRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "set_region_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_region_rect" } + } + } + + val setTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "set_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture" } + } + } + + val setVAxisStretchMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("StyleBoxTexture".cstr.ptr, + "set_v_axis_stretch_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_v_axis_stretch_mode" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/SurfaceTool.kt b/godot-kotlin/src/nativeGen/kotlin/godot/SurfaceTool.kt index f6823448..81192524 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/SurfaceTool.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/SurfaceTool.kt @@ -265,166 +265,212 @@ open class SurfaceTool( * Container for method_bind pointers for SurfaceTool */ private object __method_bind { - val addBones: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "add_bones".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_bones" } - } - val addColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "add_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_color" } - } - val addIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "add_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_index" } - } - val addNormal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "add_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_normal" } - } - val addSmoothGroup: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "add_smooth_group".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_smooth_group" } - } - val addTangent: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "add_tangent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_tangent" } - } - val addTriangleFan: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "add_triangle_fan".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_triangle_fan" } - } - val addUv: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "add_uv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_uv" } - } - val addUv2: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "add_uv2".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_uv2" } - } - val addVertex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "add_vertex".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_vertex" } - } - val addWeights: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "add_weights".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_weights" } - } - val appendFrom: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "append_from".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method append_from" } - } - val begin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "begin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method begin" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val commit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "commit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method commit" } - } - val commitToArrays: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "commit_to_arrays".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method commit_to_arrays" } - } - val createFrom: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "create_from".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_from" } - } - val createFromBlendShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "create_from_blend_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_from_blend_shape" } - } - val deindex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "deindex".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method deindex" } - } - val generateNormals: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "generate_normals".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method generate_normals" } - } - val generateTangents: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "generate_tangents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method generate_tangents" } - } - val index: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method index" } - } - val setMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, - "set_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_material" } - }} + val addBones: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "add_bones".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_bones" } + } + } + + val addColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "add_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_color" } + } + } + + val addIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "add_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_index" } + } + } + + val addNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "add_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_normal" } + } + } + + val addSmoothGroup: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "add_smooth_group".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_smooth_group" } + } + } + + val addTangent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "add_tangent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_tangent" } + } + } + + val addTriangleFan: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "add_triangle_fan".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_triangle_fan" } + } + } + + val addUv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "add_uv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_uv" } + } + } + + val addUv2: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "add_uv2".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_uv2" } + } + } + + val addVertex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "add_vertex".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_vertex" } + } + } + + val addWeights: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "add_weights".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_weights" } + } + } + + val appendFrom: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "append_from".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method append_from" } + } + } + + val begin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "begin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method begin" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val commit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "commit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method commit" } + } + } + + val commitToArrays: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "commit_to_arrays".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method commit_to_arrays" } + } + } + + val createFrom: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "create_from".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_from" } + } + } + + val createFromBlendShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "create_from_blend_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_from_blend_shape" } + } + } + + val deindex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "deindex".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method deindex" } + } + } + + val generateNormals: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "generate_normals".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method generate_normals" } + } + } + + val generateTangents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "generate_tangents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method generate_tangents" } + } + } + + val index: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method index" } + } + } + + val setMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("SurfaceTool".cstr.ptr, + "set_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_material" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/TCP_Server.kt b/godot-kotlin/src/nativeGen/kotlin/godot/TCP_Server.kt index 42ec9060..4421c818 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/TCP_Server.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/TCP_Server.kt @@ -102,35 +102,50 @@ open class TCP_Server( * Container for method_bind pointers for TCP_Server */ private object __method_bind { - val isConnectionAvailable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TCP_Server".cstr.ptr, - "is_connection_available".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_connection_available" } - } - val isListening: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TCP_Server".cstr.ptr, - "is_listening".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_listening" } - } - val listen: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TCP_Server".cstr.ptr, - "listen".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method listen" } - } - val stop: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TCP_Server".cstr.ptr, - "stop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method stop" } - } - val takeConnection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TCP_Server".cstr.ptr, - "take_connection".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method take_connection" } - }} + val isConnectionAvailable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TCP_Server".cstr.ptr, + "is_connection_available".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_connection_available" } + } + } + + val isListening: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TCP_Server".cstr.ptr, + "is_listening".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_listening" } + } + } + + val listen: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TCP_Server".cstr.ptr, + "listen".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method listen" } + } + } + + val stop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TCP_Server".cstr.ptr, + "stop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method stop" } + } + } + + val takeConnection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TCP_Server".cstr.ptr, + "take_connection".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method take_connection" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/TabContainer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/TabContainer.kt index b1173ea5..96dbc7f6 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/TabContainer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/TabContainer.kt @@ -369,173 +369,225 @@ open class TabContainer( * Container for method_bind pointers for TabContainer */ private object __method_bind { - val areTabsVisible: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "are_tabs_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method are_tabs_visible" } - } - val getCurrentTab: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "get_current_tab".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_tab" } - } - val getCurrentTabControl: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "get_current_tab_control".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_tab_control" } - } - val getDragToRearrangeEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "get_drag_to_rearrange_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_drag_to_rearrange_enabled" } - } - val getPopup: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "get_popup".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_popup" } - } - val getPreviousTab: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "get_previous_tab".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_previous_tab" } - } - val getTabAlign: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "get_tab_align".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tab_align" } - } - val getTabControl: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "get_tab_control".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tab_control" } - } - val getTabCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "get_tab_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tab_count" } - } - val getTabDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "get_tab_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tab_disabled" } - } - val getTabIcon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "get_tab_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tab_icon" } - } - val getTabTitle: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "get_tab_title".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tab_title" } - } - val getTabsRearrangeGroup: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "get_tabs_rearrange_group".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tabs_rearrange_group" } - } - val getUseHiddenTabsForMinSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "get_use_hidden_tabs_for_min_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_use_hidden_tabs_for_min_size" } - } - val setCurrentTab: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "set_current_tab".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_current_tab" } - } - val setDragToRearrangeEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "set_drag_to_rearrange_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_drag_to_rearrange_enabled" } - } - val setPopup: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "set_popup".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_popup" } - } - val setTabAlign: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "set_tab_align".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tab_align" } - } - val setTabDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "set_tab_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tab_disabled" } - } - val setTabIcon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "set_tab_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tab_icon" } - } - val setTabTitle: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "set_tab_title".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tab_title" } - } - val setTabsRearrangeGroup: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "set_tabs_rearrange_group".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tabs_rearrange_group" } - } - val setTabsVisible: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "set_tabs_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tabs_visible" } - } - val setUseHiddenTabsForMinSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, - "set_use_hidden_tabs_for_min_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_hidden_tabs_for_min_size" } - }} + val areTabsVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "are_tabs_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method are_tabs_visible" } + } + } + + val getCurrentTab: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "get_current_tab".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_tab" } + } + } + + val getCurrentTabControl: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "get_current_tab_control".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_tab_control" } + } + } + + val getDragToRearrangeEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "get_drag_to_rearrange_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_drag_to_rearrange_enabled" + } + } + } + + val getPopup: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "get_popup".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_popup" } + } + } + + val getPreviousTab: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "get_previous_tab".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_previous_tab" } + } + } + + val getTabAlign: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "get_tab_align".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tab_align" } + } + } + + val getTabControl: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "get_tab_control".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tab_control" } + } + } + + val getTabCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "get_tab_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tab_count" } + } + } + + val getTabDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "get_tab_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tab_disabled" } + } + } + + val getTabIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "get_tab_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tab_icon" } + } + } + + val getTabTitle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "get_tab_title".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tab_title" } + } + } + + val getTabsRearrangeGroup: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "get_tabs_rearrange_group".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tabs_rearrange_group" } + } + } + + val getUseHiddenTabsForMinSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "get_use_hidden_tabs_for_min_size".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_use_hidden_tabs_for_min_size" } + } + } + + val setCurrentTab: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "set_current_tab".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_current_tab" } + } + } + + val setDragToRearrangeEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "set_drag_to_rearrange_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_drag_to_rearrange_enabled" + } + } + } + + val setPopup: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "set_popup".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_popup" } + } + } + + val setTabAlign: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "set_tab_align".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tab_align" } + } + } + + val setTabDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "set_tab_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tab_disabled" } + } + } + + val setTabIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "set_tab_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tab_icon" } + } + } + + val setTabTitle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "set_tab_title".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tab_title" } + } + } + + val setTabsRearrangeGroup: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "set_tabs_rearrange_group".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tabs_rearrange_group" } + } + } + + val setTabsVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "set_tabs_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tabs_visible" } + } + } + + val setUseHiddenTabsForMinSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TabContainer".cstr.ptr, + "set_use_hidden_tabs_for_min_size".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_use_hidden_tabs_for_min_size" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Tabs.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Tabs.kt index 17109c58..f907f37c 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Tabs.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Tabs.kt @@ -431,173 +431,231 @@ open class Tabs( * Container for method_bind pointers for Tabs */ private object __method_bind { - val addTab: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "add_tab".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_tab" } - } - val ensureTabVisible: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "ensure_tab_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method ensure_tab_visible" } - } - val getCurrentTab: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "get_current_tab".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_tab" } - } - val getDragToRearrangeEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "get_drag_to_rearrange_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_drag_to_rearrange_enabled" } - } - val getOffsetButtonsVisible: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "get_offset_buttons_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_offset_buttons_visible" } - } - val getScrollingEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "get_scrolling_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_scrolling_enabled" } - } - val getSelectWithRmb: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "get_select_with_rmb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_select_with_rmb" } - } - val getTabAlign: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "get_tab_align".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tab_align" } - } - val getTabCloseDisplayPolicy: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "get_tab_close_display_policy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tab_close_display_policy" } - } - val getTabCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "get_tab_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tab_count" } - } - val getTabDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "get_tab_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tab_disabled" } - } - val getTabIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "get_tab_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tab_icon" } - } - val getTabOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "get_tab_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tab_offset" } - } - val getTabRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "get_tab_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tab_rect" } - } - val getTabTitle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "get_tab_title".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tab_title" } - } - val getTabsRearrangeGroup: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "get_tabs_rearrange_group".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tabs_rearrange_group" } - } - val moveTab: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "move_tab".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method move_tab" } - } - val removeTab: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "remove_tab".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_tab" } - } - val setCurrentTab: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "set_current_tab".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_current_tab" } - } - val setDragToRearrangeEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "set_drag_to_rearrange_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_drag_to_rearrange_enabled" } - } - val setScrollingEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "set_scrolling_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_scrolling_enabled" } - } - val setSelectWithRmb: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "set_select_with_rmb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_select_with_rmb" } - } - val setTabAlign: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "set_tab_align".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tab_align" } - } - val setTabCloseDisplayPolicy: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "set_tab_close_display_policy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tab_close_display_policy" } - } - val setTabDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "set_tab_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tab_disabled" } - } - val setTabIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "set_tab_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tab_icon" } - } - val setTabTitle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "set_tab_title".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tab_title" } - } - val setTabsRearrangeGroup: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, - "set_tabs_rearrange_group".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tabs_rearrange_group" } - }} + val addTab: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "add_tab".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_tab" } + } + } + + val ensureTabVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "ensure_tab_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method ensure_tab_visible" } + } + } + + val getCurrentTab: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "get_current_tab".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_tab" } + } + } + + val getDragToRearrangeEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "get_drag_to_rearrange_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_drag_to_rearrange_enabled" + } + } + } + + val getOffsetButtonsVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "get_offset_buttons_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_offset_buttons_visible" } + } + } + + val getScrollingEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "get_scrolling_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_scrolling_enabled" } + } + } + + val getSelectWithRmb: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "get_select_with_rmb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_select_with_rmb" } + } + } + + val getTabAlign: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "get_tab_align".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tab_align" } + } + } + + val getTabCloseDisplayPolicy: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "get_tab_close_display_policy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tab_close_display_policy" } + } + } + + val getTabCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "get_tab_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tab_count" } + } + } + + val getTabDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "get_tab_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tab_disabled" } + } + } + + val getTabIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "get_tab_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tab_icon" } + } + } + + val getTabOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "get_tab_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tab_offset" } + } + } + + val getTabRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "get_tab_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tab_rect" } + } + } + + val getTabTitle: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "get_tab_title".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tab_title" } + } + } + + val getTabsRearrangeGroup: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "get_tabs_rearrange_group".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tabs_rearrange_group" } + } + } + + val moveTab: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "move_tab".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method move_tab" } + } + } + + val removeTab: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "remove_tab".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_tab" } + } + } + + val setCurrentTab: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "set_current_tab".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_current_tab" } + } + } + + val setDragToRearrangeEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "set_drag_to_rearrange_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_drag_to_rearrange_enabled" + } + } + } + + val setScrollingEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "set_scrolling_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_scrolling_enabled" } + } + } + + val setSelectWithRmb: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "set_select_with_rmb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_select_with_rmb" } + } + } + + val setTabAlign: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "set_tab_align".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tab_align" } + } + } + + val setTabCloseDisplayPolicy: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "set_tab_close_display_policy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tab_close_display_policy" } + } + } + + val setTabDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "set_tab_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tab_disabled" } + } + } + + val setTabIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "set_tab_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tab_icon" } + } + } + + val setTabTitle: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "set_tab_title".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tab_title" } + } + } + + val setTabsRearrangeGroup: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tabs".cstr.ptr, + "set_tabs_rearrange_group".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tabs_rearrange_group" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/TextEdit.kt b/godot-kotlin/src/nativeGen/kotlin/godot/TextEdit.kt index fdfb0820..30228487 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/TextEdit.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/TextEdit.kt @@ -1251,578 +1251,866 @@ open class TextEdit( * Container for method_bind pointers for TextEdit */ private object __method_bind { - val addColorRegion: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "add_color_region".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_color_region" } - } - val addKeywordColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "add_keyword_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_keyword_color" } - } - val canFold: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "can_fold".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method can_fold" } - } - val centerViewportToCursor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "center_viewport_to_cursor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method center_viewport_to_cursor" } - } - val clearColors: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "clear_colors".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_colors" } - } - val clearUndoHistory: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "clear_undo_history".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_undo_history" } - } - val copy: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "copy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method copy" } - } - val cursorGetBlinkEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "cursor_get_blink_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cursor_get_blink_enabled" } - } - val cursorGetBlinkSpeed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "cursor_get_blink_speed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cursor_get_blink_speed" } - } - val cursorGetColumn: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "cursor_get_column".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cursor_get_column" } - } - val cursorGetLine: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "cursor_get_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cursor_get_line" } - } - val cursorIsBlockMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "cursor_is_block_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cursor_is_block_mode" } - } - val cursorSetBlinkEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "cursor_set_blink_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cursor_set_blink_enabled" } - } - val cursorSetBlinkSpeed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "cursor_set_blink_speed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cursor_set_blink_speed" } - } - val cursorSetBlockMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "cursor_set_block_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cursor_set_block_mode" } - } - val cursorSetColumn: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "cursor_set_column".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cursor_set_column" } - } - val cursorSetLine: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "cursor_set_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cursor_set_line" } - } - val cut: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "cut".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method cut" } - } - val deselect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "deselect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method deselect" } - } - val drawMinimap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "draw_minimap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_minimap" } - } - val foldAllLines: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "fold_all_lines".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method fold_all_lines" } - } - val foldLine: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "fold_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method fold_line" } - } - val getBreakpoints: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "get_breakpoints".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_breakpoints" } - } - val getHScroll: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "get_h_scroll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_h_scroll" } - } - val getKeywordColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "get_keyword_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_keyword_color" } - } - val getLine: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "get_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_line" } - } - val getLineCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "get_line_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_line_count" } - } - val getMenu: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "get_menu".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_menu" } - } - val getMinimapWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "get_minimap_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_minimap_width" } - } - val getSelectionFromColumn: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "get_selection_from_column".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_selection_from_column" } - } - val getSelectionFromLine: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "get_selection_from_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_selection_from_line" } - } - val getSelectionText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "get_selection_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_selection_text" } - } - val getSelectionToColumn: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "get_selection_to_column".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_selection_to_column" } - } - val getSelectionToLine: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "get_selection_to_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_selection_to_line" } - } - val getText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "get_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_text" } - } - val getVScroll: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "get_v_scroll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_v_scroll" } - } - val getVScrollSpeed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "get_v_scroll_speed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_v_scroll_speed" } - } - val getWordUnderCursor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "get_word_under_cursor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_word_under_cursor" } - } - val hasKeywordColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "has_keyword_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_keyword_color" } - } - val insertTextAtCursor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "insert_text_at_cursor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method insert_text_at_cursor" } - } - val isBreakpointGutterEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_breakpoint_gutter_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_breakpoint_gutter_enabled" } - } - val isContextMenuEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_context_menu_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_context_menu_enabled" } - } - val isDrawingFoldGutter: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_drawing_fold_gutter".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_drawing_fold_gutter" } - } - val isDrawingMinimap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_drawing_minimap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_drawing_minimap" } - } - val isDrawingSpaces: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_drawing_spaces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_drawing_spaces" } - } - val isDrawingTabs: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_drawing_tabs".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_drawing_tabs" } - } - val isFolded: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_folded".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_folded" } - } - val isHidingEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_hiding_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_hiding_enabled" } - } - val isHighlightAllOccurrencesEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_highlight_all_occurrences_enabled".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method is_highlight_all_occurrences_enabled" } - } - val isHighlightCurrentLineEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_highlight_current_line_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_highlight_current_line_enabled" + val addColorRegion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "add_color_region".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_color_region" } } - } - val isLineHidden: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_line_hidden".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_line_hidden" } - } - val isOverridingSelectedFontColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_overriding_selected_font_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_overriding_selected_font_color" + } + + val addKeywordColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "add_keyword_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_keyword_color" } } - } - val isReadonly: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_readonly".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_readonly" } - } - val isRightClickMovingCaret: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_right_click_moving_caret".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_right_click_moving_caret" } - } - val isSelectingEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_selecting_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_selecting_enabled" } - } - val isSelectionActive: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_selection_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_selection_active" } - } - val isShortcutKeysEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_shortcut_keys_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_shortcut_keys_enabled" } - } - val isShowLineNumbersEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_show_line_numbers_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_show_line_numbers_enabled" } - } - val isSmoothScrollEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_smooth_scroll_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_smooth_scroll_enabled" } - } - val isSyntaxColoringEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_syntax_coloring_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_syntax_coloring_enabled" } - } - val isWrapEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "is_wrap_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_wrap_enabled" } - } - val menuOption: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "menu_option".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method menu_option" } - } - val paste: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "paste".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method paste" } - } - val redo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "redo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method redo" } - } - val removeBreakpoints: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "remove_breakpoints".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_breakpoints" } - } - val search: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "search".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method search" } - } - val select: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "select".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method select" } - } - val selectAll: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "select_all".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method select_all" } - } - val setBreakpointGutterEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_breakpoint_gutter_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_breakpoint_gutter_enabled" } - } - val setContextMenuEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_context_menu_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_context_menu_enabled" } - } - val setDrawFoldGutter: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_draw_fold_gutter".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_draw_fold_gutter" } - } - val setDrawSpaces: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_draw_spaces".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_draw_spaces" } - } - val setDrawTabs: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_draw_tabs".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_draw_tabs" } - } - val setHScroll: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_h_scroll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_h_scroll" } - } - val setHidingEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_hiding_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_hiding_enabled" } - } - val setHighlightAllOccurrences: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_highlight_all_occurrences".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_highlight_all_occurrences" } - } - val setHighlightCurrentLine: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_highlight_current_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_highlight_current_line" } - } - val setLineAsHidden: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_line_as_hidden".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_line_as_hidden" } - } - val setMinimapWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_minimap_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_minimap_width" } - } - val setOverrideSelectedFontColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_override_selected_font_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_override_selected_font_color" } - } - val setReadonly: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_readonly".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_readonly" } - } - val setRightClickMovesCaret: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_right_click_moves_caret".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_right_click_moves_caret" } - } - val setSelectingEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_selecting_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_selecting_enabled" } - } - val setShortcutKeysEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_shortcut_keys_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shortcut_keys_enabled" } - } - val setShowLineNumbers: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_show_line_numbers".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_show_line_numbers" } - } - val setSmoothScrollEnable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_smooth_scroll_enable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_smooth_scroll_enable" } - } - val setSyntaxColoring: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_syntax_coloring".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_syntax_coloring" } - } - val setText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_text" } - } - val setVScroll: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_v_scroll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_v_scroll" } - } - val setVScrollSpeed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_v_scroll_speed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_v_scroll_speed" } - } - val setWrapEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "set_wrap_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_wrap_enabled" } - } - val toggleFoldLine: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "toggle_fold_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method toggle_fold_line" } - } - val undo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "undo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method undo" } - } - val unfoldLine: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "unfold_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method unfold_line" } - } - val unhideAllLines: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, - "unhide_all_lines".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method unhide_all_lines" } - }} + } + + val canFold: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "can_fold".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method can_fold" } + } + } + + val centerViewportToCursor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "center_viewport_to_cursor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method center_viewport_to_cursor" } + } + } + + val clearColors: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "clear_colors".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_colors" } + } + } + + val clearUndoHistory: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "clear_undo_history".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_undo_history" } + } + } + + val copy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "copy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method copy" } + } + } + + val cursorGetBlinkEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "cursor_get_blink_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cursor_get_blink_enabled" } + } + } + + val cursorGetBlinkSpeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "cursor_get_blink_speed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cursor_get_blink_speed" } + } + } + + val cursorGetColumn: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "cursor_get_column".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cursor_get_column" } + } + } + + val cursorGetLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "cursor_get_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cursor_get_line" } + } + } + + val cursorIsBlockMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "cursor_is_block_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cursor_is_block_mode" } + } + } + + val cursorSetBlinkEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "cursor_set_blink_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cursor_set_blink_enabled" } + } + } + + val cursorSetBlinkSpeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "cursor_set_blink_speed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cursor_set_blink_speed" } + } + } + + val cursorSetBlockMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "cursor_set_block_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cursor_set_block_mode" } + } + } + + val cursorSetColumn: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "cursor_set_column".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cursor_set_column" } + } + } + + val cursorSetLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "cursor_set_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cursor_set_line" } + } + } + + val cut: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "cut".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method cut" } + } + } + + val deselect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "deselect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method deselect" } + } + } + + val drawMinimap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "draw_minimap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_minimap" } + } + } + + val foldAllLines: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "fold_all_lines".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method fold_all_lines" } + } + } + + val foldLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "fold_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method fold_line" } + } + } + + val getBreakpoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "get_breakpoints".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_breakpoints" } + } + } + + val getHScroll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "get_h_scroll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_h_scroll" } + } + } + + val getKeywordColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "get_keyword_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_keyword_color" } + } + } + + val getLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "get_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_line" } + } + } + + val getLineCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "get_line_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_line_count" } + } + } + + val getMenu: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "get_menu".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_menu" } + } + } + + val getMinimapWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "get_minimap_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_minimap_width" } + } + } + + val getSelectionFromColumn: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "get_selection_from_column".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_selection_from_column" } + } + } + + val getSelectionFromLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "get_selection_from_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_selection_from_line" } + } + } + + val getSelectionText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "get_selection_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_selection_text" } + } + } + + val getSelectionToColumn: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "get_selection_to_column".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_selection_to_column" } + } + } + + val getSelectionToLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "get_selection_to_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_selection_to_line" } + } + } + + val getText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "get_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_text" } + } + } + + val getVScroll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "get_v_scroll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_v_scroll" } + } + } + + val getVScrollSpeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "get_v_scroll_speed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_v_scroll_speed" } + } + } + + val getWordUnderCursor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "get_word_under_cursor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_word_under_cursor" } + } + } + + val hasKeywordColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "has_keyword_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_keyword_color" } + } + } + + val insertTextAtCursor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "insert_text_at_cursor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method insert_text_at_cursor" } + } + } + + val isBreakpointGutterEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_breakpoint_gutter_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_breakpoint_gutter_enabled" } + } + } + + val isContextMenuEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_context_menu_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_context_menu_enabled" } + } + } + + val isDrawingFoldGutter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_drawing_fold_gutter".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_drawing_fold_gutter" } + } + } + + val isDrawingMinimap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_drawing_minimap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_drawing_minimap" } + } + } + + val isDrawingSpaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_drawing_spaces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_drawing_spaces" } + } + } + + val isDrawingTabs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_drawing_tabs".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_drawing_tabs" } + } + } + + val isFolded: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_folded".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_folded" } + } + } + + val isHidingEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_hiding_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_hiding_enabled" } + } + } + + val isHighlightAllOccurrencesEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_highlight_all_occurrences_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_highlight_all_occurrences_enabled" } + } + } + + val isHighlightCurrentLineEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_highlight_current_line_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_highlight_current_line_enabled" } + } + } + + val isLineHidden: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_line_hidden".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_line_hidden" } + } + } + + val isOverridingSelectedFontColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_overriding_selected_font_color".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_overriding_selected_font_color" } + } + } + + val isReadonly: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_readonly".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_readonly" } + } + } + + val isRightClickMovingCaret: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_right_click_moving_caret".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_right_click_moving_caret" } + } + } + + val isSelectingEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_selecting_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_selecting_enabled" } + } + } + + val isSelectionActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_selection_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_selection_active" } + } + } + + val isShortcutKeysEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_shortcut_keys_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_shortcut_keys_enabled" } + } + } + + val isShowLineNumbersEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_show_line_numbers_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_show_line_numbers_enabled" } + } + } + + val isSmoothScrollEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_smooth_scroll_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_smooth_scroll_enabled" } + } + } + + val isSyntaxColoringEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_syntax_coloring_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_syntax_coloring_enabled" } + } + } + + val isWrapEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "is_wrap_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_wrap_enabled" } + } + } + + val menuOption: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "menu_option".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method menu_option" } + } + } + + val paste: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "paste".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method paste" } + } + } + + val redo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "redo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method redo" } + } + } + + val removeBreakpoints: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "remove_breakpoints".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_breakpoints" } + } + } + + val search: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "search".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method search" } + } + } + + val select: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "select".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method select" } + } + } + + val selectAll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "select_all".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method select_all" } + } + } + + val setBreakpointGutterEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_breakpoint_gutter_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_breakpoint_gutter_enabled" + } + } + } + + val setContextMenuEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_context_menu_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_context_menu_enabled" } + } + } + + val setDrawFoldGutter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_draw_fold_gutter".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_draw_fold_gutter" } + } + } + + val setDrawSpaces: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_draw_spaces".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_draw_spaces" } + } + } + + val setDrawTabs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_draw_tabs".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_draw_tabs" } + } + } + + val setHScroll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_h_scroll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_h_scroll" } + } + } + + val setHidingEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_hiding_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_hiding_enabled" } + } + } + + val setHighlightAllOccurrences: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_highlight_all_occurrences".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_highlight_all_occurrences" + } + } + } + + val setHighlightCurrentLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_highlight_current_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_highlight_current_line" } + } + } + + val setLineAsHidden: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_line_as_hidden".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_line_as_hidden" } + } + } + + val setMinimapWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_minimap_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_minimap_width" } + } + } + + val setOverrideSelectedFontColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_override_selected_font_color".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_override_selected_font_color" } + } + } + + val setReadonly: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_readonly".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_readonly" } + } + } + + val setRightClickMovesCaret: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_right_click_moves_caret".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_right_click_moves_caret" } + } + } + + val setSelectingEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_selecting_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_selecting_enabled" } + } + } + + val setShortcutKeysEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_shortcut_keys_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shortcut_keys_enabled" } + } + } + + val setShowLineNumbers: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_show_line_numbers".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_show_line_numbers" } + } + } + + val setSmoothScrollEnable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_smooth_scroll_enable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_smooth_scroll_enable" } + } + } + + val setSyntaxColoring: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_syntax_coloring".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_syntax_coloring" } + } + } + + val setText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_text" } + } + } + + val setVScroll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_v_scroll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_v_scroll" } + } + } + + val setVScrollSpeed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_v_scroll_speed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_v_scroll_speed" } + } + } + + val setWrapEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "set_wrap_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_wrap_enabled" } + } + } + + val toggleFoldLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "toggle_fold_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method toggle_fold_line" } + } + } + + val undo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "undo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method undo" } + } + } + + val unfoldLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "unfold_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method unfold_line" } + } + } + + val unhideAllLines: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextEdit".cstr.ptr, + "unhide_all_lines".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method unhide_all_lines" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Texture.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Texture.kt index b351db14..e549d1ee 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Texture.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Texture.kt @@ -219,65 +219,95 @@ open class Texture( * Container for method_bind pointers for Texture */ private object __method_bind { - val draw: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, - "draw".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw" } - } - val drawRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, - "draw_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_rect" } - } - val drawRectRegion: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, - "draw_rect_region".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw_rect_region" } - } - val getData: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, - "get_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_data" } - } - val getFlags: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, - "get_flags".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_flags" } - } - val getHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, - "get_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_height" } - } - val getSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, - "get_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_size" } - } - val getWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, - "get_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_width" } - } - val hasAlpha: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, - "has_alpha".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_alpha" } - } - val setFlags: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, - "set_flags".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flags" } - }} + val draw: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, + "draw".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw" } + } + } + + val drawRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, + "draw_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_rect" } + } + } + + val drawRectRegion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, + "draw_rect_region".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw_rect_region" } + } + } + + val getData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, + "get_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_data" } + } + } + + val getFlags: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, + "get_flags".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_flags" } + } + } + + val getHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, + "get_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_height" } + } + } + + val getSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, + "get_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_size" } + } + } + + val getWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, + "get_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_width" } + } + } + + val hasAlpha: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, + "has_alpha".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_alpha" } + } + } + + val setFlags: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Texture".cstr.ptr, + "set_flags".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flags" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/TextureButton.kt b/godot-kotlin/src/nativeGen/kotlin/godot/TextureButton.kt index cab867b1..1818f4bb 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/TextureButton.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/TextureButton.kt @@ -290,117 +290,149 @@ open class TextureButton( * Container for method_bind pointers for TextureButton */ private object __method_bind { - val getClickMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, - "get_click_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_click_mask" } - } - val getDisabledTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, - "get_disabled_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_disabled_texture" } - } - val getExpand: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, - "get_expand".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_expand" } - } - val getFocusedTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, - "get_focused_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_focused_texture" } - } - val getHoverTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, - "get_hover_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_hover_texture" } - } - val getNormalTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, - "get_normal_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_normal_texture" } - } - val getPressedTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, - "get_pressed_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pressed_texture" } - } - val getStretchMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, - "get_stretch_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stretch_mode" } - } - val setClickMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, - "set_click_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_click_mask" } - } - val setDisabledTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, - "set_disabled_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_disabled_texture" } - } - val setExpand: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, - "set_expand".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_expand" } - } - val setFocusedTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, - "set_focused_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_focused_texture" } - } - val setHoverTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, - "set_hover_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_hover_texture" } - } - val setNormalTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, - "set_normal_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_normal_texture" } - } - val setPressedTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, - "set_pressed_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_pressed_texture" } - } - val setStretchMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, - "set_stretch_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_stretch_mode" } - }} + val getClickMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, + "get_click_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_click_mask" } + } + } + + val getDisabledTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, + "get_disabled_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_disabled_texture" } + } + } + + val getExpand: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, + "get_expand".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_expand" } + } + } + + val getFocusedTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, + "get_focused_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_focused_texture" } + } + } + + val getHoverTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, + "get_hover_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_hover_texture" } + } + } + + val getNormalTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, + "get_normal_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_normal_texture" } + } + } + + val getPressedTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, + "get_pressed_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pressed_texture" } + } + } + + val getStretchMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, + "get_stretch_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stretch_mode" } + } + } + + val setClickMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, + "set_click_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_click_mask" } + } + } + + val setDisabledTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, + "set_disabled_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_disabled_texture" } + } + } + + val setExpand: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, + "set_expand".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_expand" } + } + } + + val setFocusedTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, + "set_focused_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_focused_texture" } + } + } + + val setHoverTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, + "set_hover_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_hover_texture" } + } + } + + val setNormalTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, + "set_normal_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_normal_texture" } + } + } + + val setPressedTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, + "set_pressed_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_pressed_texture" } + } + } + + val setStretchMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureButton".cstr.ptr, + "set_stretch_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_stretch_mode" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/TextureLayered.kt b/godot-kotlin/src/nativeGen/kotlin/godot/TextureLayered.kt index e52bc978..d1041bb3 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/TextureLayered.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/TextureLayered.kt @@ -199,75 +199,95 @@ open class TextureLayered( * Container for method_bind pointers for TextureLayered */ private object __method_bind { - val create: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, - "create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create" } - } - val getDepth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, - "get_depth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_depth" } - } - val getFlags: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, - "get_flags".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_flags" } - } - val getFormat: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, - "get_format".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_format" } - } - val getHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, - "get_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_height" } - } - val getLayerData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, - "get_layer_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_layer_data" } - } - val getWidth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, - "get_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_width" } - } - val setDataPartial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, - "set_data_partial".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_data_partial" } - } - val setFlags: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, - "set_flags".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flags" } - } - val setLayerData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, - "set_layer_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_layer_data" } - }} + val create: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, + "create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create" } + } + } + + val getDepth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, + "get_depth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_depth" } + } + } + + val getFlags: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, + "get_flags".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_flags" } + } + } + + val getFormat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, + "get_format".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_format" } + } + } + + val getHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, + "get_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_height" } + } + } + + val getLayerData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, + "get_layer_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_layer_data" } + } + } + + val getWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, + "get_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_width" } + } + } + + val setDataPartial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, + "set_data_partial".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_data_partial" } + } + } + + val setFlags: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, + "set_flags".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flags" } + } + } + + val setLayerData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureLayered".cstr.ptr, + "set_layer_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_layer_data" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/TextureProgress.kt b/godot-kotlin/src/nativeGen/kotlin/godot/TextureProgress.kt index bbac7c2d..7ae2005e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/TextureProgress.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/TextureProgress.kt @@ -460,173 +460,221 @@ open class TextureProgress( * Container for method_bind pointers for TextureProgress */ private object __method_bind { - val getFillDegrees: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "get_fill_degrees".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fill_degrees" } - } - val getFillMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "get_fill_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fill_mode" } - } - val getNinePatchStretch: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "get_nine_patch_stretch".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_nine_patch_stretch" } - } - val getOverTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "get_over_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_over_texture" } - } - val getProgressTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "get_progress_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_progress_texture" } - } - val getRadialCenterOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "get_radial_center_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_radial_center_offset" } - } - val getRadialInitialAngle: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "get_radial_initial_angle".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_radial_initial_angle" } - } - val getStretchMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "get_stretch_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stretch_margin" } - } - val getTintOver: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "get_tint_over".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tint_over" } - } - val getTintProgress: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "get_tint_progress".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tint_progress" } - } - val getTintUnder: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "get_tint_under".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tint_under" } - } - val getUnderTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "get_under_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_under_texture" } - } - val setFillDegrees: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "set_fill_degrees".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fill_degrees" } - } - val setFillMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "set_fill_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fill_mode" } - } - val setNinePatchStretch: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "set_nine_patch_stretch".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_nine_patch_stretch" } - } - val setOverTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "set_over_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_over_texture" } - } - val setProgressTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "set_progress_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_progress_texture" } - } - val setRadialCenterOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "set_radial_center_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_radial_center_offset" } - } - val setRadialInitialAngle: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "set_radial_initial_angle".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_radial_initial_angle" } - } - val setStretchMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "set_stretch_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_stretch_margin" } - } - val setTintOver: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "set_tint_over".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tint_over" } - } - val setTintProgress: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "set_tint_progress".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tint_progress" } - } - val setTintUnder: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "set_tint_under".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tint_under" } - } - val setUnderTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, - "set_under_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_under_texture" } - }} + val getFillDegrees: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "get_fill_degrees".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fill_degrees" } + } + } + + val getFillMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "get_fill_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fill_mode" } + } + } + + val getNinePatchStretch: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "get_nine_patch_stretch".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_nine_patch_stretch" } + } + } + + val getOverTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "get_over_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_over_texture" } + } + } + + val getProgressTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "get_progress_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_progress_texture" } + } + } + + val getRadialCenterOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "get_radial_center_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_radial_center_offset" } + } + } + + val getRadialInitialAngle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "get_radial_initial_angle".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_radial_initial_angle" } + } + } + + val getStretchMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "get_stretch_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stretch_margin" } + } + } + + val getTintOver: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "get_tint_over".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tint_over" } + } + } + + val getTintProgress: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "get_tint_progress".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tint_progress" } + } + } + + val getTintUnder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "get_tint_under".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tint_under" } + } + } + + val getUnderTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "get_under_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_under_texture" } + } + } + + val setFillDegrees: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "set_fill_degrees".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fill_degrees" } + } + } + + val setFillMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "set_fill_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fill_mode" } + } + } + + val setNinePatchStretch: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "set_nine_patch_stretch".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_nine_patch_stretch" } + } + } + + val setOverTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "set_over_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_over_texture" } + } + } + + val setProgressTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "set_progress_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_progress_texture" } + } + } + + val setRadialCenterOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "set_radial_center_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_radial_center_offset" } + } + } + + val setRadialInitialAngle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "set_radial_initial_angle".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_radial_initial_angle" } + } + } + + val setStretchMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "set_stretch_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_stretch_margin" } + } + } + + val setTintOver: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "set_tint_over".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tint_over" } + } + } + + val setTintProgress: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "set_tint_progress".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tint_progress" } + } + } + + val setTintUnder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "set_tint_under".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tint_under" } + } + } + + val setUnderTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureProgress".cstr.ptr, + "set_under_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_under_texture" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/TextureRect.kt b/godot-kotlin/src/nativeGen/kotlin/godot/TextureRect.kt index 1aec627c..e2781c56 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/TextureRect.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/TextureRect.kt @@ -211,75 +211,95 @@ open class TextureRect( * Container for method_bind pointers for TextureRect */ private object __method_bind { - val getStretchMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, - "get_stretch_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stretch_mode" } - } - val getTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, - "get_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture" } - } - val hasExpand: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, - "has_expand".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_expand" } - } - val isFlippedH: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, - "is_flipped_h".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_flipped_h" } - } - val isFlippedV: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, - "is_flipped_v".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_flipped_v" } - } - val setExpand: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, - "set_expand".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_expand" } - } - val setFlipH: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, - "set_flip_h".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flip_h" } - } - val setFlipV: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, - "set_flip_v".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_flip_v" } - } - val setStretchMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, - "set_stretch_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_stretch_mode" } - } - val setTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, - "set_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture" } - }} + val getStretchMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, + "get_stretch_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stretch_mode" } + } + } + + val getTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, + "get_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture" } + } + } + + val hasExpand: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, + "has_expand".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_expand" } + } + } + + val isFlippedH: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, + "is_flipped_h".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_flipped_h" } + } + } + + val isFlippedV: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, + "is_flipped_v".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_flipped_v" } + } + } + + val setExpand: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, + "set_expand".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_expand" } + } + } + + val setFlipH: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, + "set_flip_h".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flip_h" } + } + } + + val setFlipV: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, + "set_flip_v".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_flip_v" } + } + } + + val setStretchMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, + "set_stretch_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_stretch_mode" } + } + } + + val setTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TextureRect".cstr.ptr, + "set_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Theme.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Theme.kt index 3c99f742..82e6a0af 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Theme.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Theme.kt @@ -442,197 +442,261 @@ open class Theme( * Container for method_bind pointers for Theme */ private object __method_bind { - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val clearColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "clear_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_color" } - } - val clearConstant: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "clear_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_constant" } - } - val clearFont: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "clear_font".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_font" } - } - val clearIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "clear_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_icon" } - } - val clearStylebox: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "clear_stylebox".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_stylebox" } - } - val copyDefaultTheme: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "copy_default_theme".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method copy_default_theme" } - } - val copyTheme: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "copy_theme".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method copy_theme" } - } - val getColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "get_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_color" } - } - val getColorList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "get_color_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_color_list" } - } - val getConstant: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "get_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_constant" } - } - val getConstantList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "get_constant_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_constant_list" } - } - val getDefaultFont: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "get_default_font".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_default_font" } - } - val getFont: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "get_font".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_font" } - } - val getFontList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "get_font_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_font_list" } - } - val getIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "get_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_icon" } - } - val getIconList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "get_icon_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_icon_list" } - } - val getStylebox: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "get_stylebox".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stylebox" } - } - val getStyleboxList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "get_stylebox_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stylebox_list" } - } - val getStyleboxTypes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "get_stylebox_types".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stylebox_types" } - } - val getTypeList: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "get_type_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_type_list" } - } - val hasColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "has_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_color" } - } - val hasConstant: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "has_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_constant" } - } - val hasFont: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "has_font".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_font" } - } - val hasIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "has_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_icon" } - } - val hasStylebox: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "has_stylebox".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_stylebox" } - } - val setColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "set_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_color" } - } - val setConstant: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "set_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_constant" } - } - val setDefaultFont: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "set_default_font".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_default_font" } - } - val setFont: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "set_font".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_font" } - } - val setIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "set_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_icon" } - } - val setStylebox: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, - "set_stylebox".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_stylebox" } - }} + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val clearColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "clear_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_color" } + } + } + + val clearConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "clear_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_constant" } + } + } + + val clearFont: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "clear_font".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_font" } + } + } + + val clearIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "clear_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_icon" } + } + } + + val clearStylebox: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "clear_stylebox".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_stylebox" } + } + } + + val copyDefaultTheme: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "copy_default_theme".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method copy_default_theme" } + } + } + + val copyTheme: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "copy_theme".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method copy_theme" } + } + } + + val getColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "get_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_color" } + } + } + + val getColorList: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "get_color_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_color_list" } + } + } + + val getConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "get_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_constant" } + } + } + + val getConstantList: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "get_constant_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_constant_list" } + } + } + + val getDefaultFont: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "get_default_font".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_default_font" } + } + } + + val getFont: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "get_font".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_font" } + } + } + + val getFontList: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "get_font_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_font_list" } + } + } + + val getIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "get_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_icon" } + } + } + + val getIconList: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "get_icon_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_icon_list" } + } + } + + val getStylebox: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "get_stylebox".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stylebox" } + } + } + + val getStyleboxList: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "get_stylebox_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stylebox_list" } + } + } + + val getStyleboxTypes: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "get_stylebox_types".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stylebox_types" } + } + } + + val getTypeList: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "get_type_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_type_list" } + } + } + + val hasColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "has_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_color" } + } + } + + val hasConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "has_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_constant" } + } + } + + val hasFont: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "has_font".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_font" } + } + } + + val hasIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "has_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_icon" } + } + } + + val hasStylebox: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "has_stylebox".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_stylebox" } + } + } + + val setColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "set_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_color" } + } + } + + val setConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "set_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_constant" } + } + } + + val setDefaultFont: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "set_default_font".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_default_font" } + } + } + + val setFont: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "set_font".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_font" } + } + } + + val setIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "set_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_icon" } + } + } + + val setStylebox: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Theme".cstr.ptr, + "set_stylebox".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_stylebox" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Thread.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Thread.kt index 70967e2d..68c6fc4c 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Thread.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Thread.kt @@ -123,29 +123,41 @@ open class Thread( * Container for method_bind pointers for Thread */ private object __method_bind { - val getId: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Thread".cstr.ptr, - "get_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_id" } - } - val isActive: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Thread".cstr.ptr, - "is_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_active" } - } - val start: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Thread".cstr.ptr, - "start".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method start" } - } - val waitToFinish: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Thread".cstr.ptr, - "wait_to_finish".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method wait_to_finish" } - }} + val getId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Thread".cstr.ptr, + "get_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_id" } + } + } + + val isActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Thread".cstr.ptr, + "is_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_active" } + } + } + + val start: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Thread".cstr.ptr, + "start".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method start" } + } + } + + val waitToFinish: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_Thread".cstr.ptr, + "wait_to_finish".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method wait_to_finish" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/TileMap.kt b/godot-kotlin/src/nativeGen/kotlin/godot/TileMap.kt index 70912f3c..d0c0637d 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/TileMap.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/TileMap.kt @@ -884,353 +884,528 @@ open class TileMap( * Container for method_bind pointers for TileMap */ private object __method_bind { - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val fixInvalidTiles: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "fix_invalid_tiles".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method fix_invalid_tiles" } - } - val getCell: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_cell".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cell" } - } - val getCellAutotileCoord: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_cell_autotile_coord".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cell_autotile_coord" } - } - val getCellSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_cell_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cell_size" } - } - val getCellv: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_cellv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cellv" } - } - val getClipUv: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_clip_uv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_clip_uv" } - } - val getCollisionBounce: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_collision_bounce".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_bounce" } - } - val getCollisionFriction: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_collision_friction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_friction" } - } - val getCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_layer" } - } - val getCollisionLayerBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_collision_layer_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_layer_bit" } - } - val getCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } - } - val getCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } - } - val getCollisionUseKinematic: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_collision_use_kinematic".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_use_kinematic" } - } - val getCollisionUseParent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_collision_use_parent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_collision_use_parent" } - } - val getCustomTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_custom_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_custom_transform" } - } - val getHalfOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_half_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_half_offset" } - } - val getMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mode" } - } - val getOccluderLightMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_occluder_light_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_occluder_light_mask" } - } - val getQuadrantSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_quadrant_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_quadrant_size" } - } - val getTileOrigin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_tile_origin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tile_origin" } - } - val getTileset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_tileset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tileset" } - } - val getUsedCells: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_used_cells".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_used_cells" } - } - val getUsedCellsById: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_used_cells_by_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_used_cells_by_id" } - } - val getUsedRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "get_used_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_used_rect" } - } - val isCellTransposed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "is_cell_transposed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_cell_transposed" } - } - val isCellXFlipped: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "is_cell_x_flipped".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_cell_x_flipped" } - } - val isCellYFlipped: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "is_cell_y_flipped".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_cell_y_flipped" } - } - val isCenteredTexturesEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "is_centered_textures_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_centered_textures_enabled" } - } - val isCompatibilityModeEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "is_compatibility_mode_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_compatibility_mode_enabled" } - } - val isYSortModeEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "is_y_sort_mode_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_y_sort_mode_enabled" } - } - val mapToWorld: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "map_to_world".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method map_to_world" } - } - val setCell: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_cell".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cell" } - } - val setCellSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_cell_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cell_size" } - } - val setCellv: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_cellv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cellv" } - } - val setCenteredTextures: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_centered_textures".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_centered_textures" } - } - val setClipUv: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_clip_uv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_clip_uv" } - } - val setCollisionBounce: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_collision_bounce".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_bounce" } - } - val setCollisionFriction: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_collision_friction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_friction" } - } - val setCollisionLayer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_collision_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_layer" } - } - val setCollisionLayerBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_collision_layer_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_layer_bit" } - } - val setCollisionMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_collision_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } - } - val setCollisionMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_collision_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } - } - val setCollisionUseKinematic: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_collision_use_kinematic".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_use_kinematic" } - } - val setCollisionUseParent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_collision_use_parent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collision_use_parent" } - } - val setCompatibilityMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_compatibility_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_compatibility_mode" } - } - val setCustomTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_custom_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_custom_transform" } - } - val setHalfOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_half_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_half_offset" } - } - val setMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mode" } - } - val setOccluderLightMask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_occluder_light_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_occluder_light_mask" } - } - val setQuadrantSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_quadrant_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_quadrant_size" } - } - val setTileOrigin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_tile_origin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tile_origin" } - } - val setTileset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_tileset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tileset" } - } - val setYSortMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "set_y_sort_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_y_sort_mode" } - } - val updateBitmaskArea: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "update_bitmask_area".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method update_bitmask_area" } - } - val updateBitmaskRegion: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "update_bitmask_region".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method update_bitmask_region" } - } - val updateDirtyQuadrants: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "update_dirty_quadrants".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method update_dirty_quadrants" } - } - val worldToMap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, - "world_to_map".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method world_to_map" } - }} + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val fixInvalidTiles: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "fix_invalid_tiles".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method fix_invalid_tiles" } + } + } + + val getCell: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_cell".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cell" } + } + } + + val getCellAutotileCoord: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_cell_autotile_coord".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cell_autotile_coord" } + } + } + + val getCellSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_cell_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cell_size" } + } + } + + val getCellv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_cellv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cellv" } + } + } + + val getClipUv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_clip_uv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_clip_uv" } + } + } + + val getCollisionBounce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_collision_bounce".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_bounce" } + } + } + + val getCollisionFriction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_collision_friction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_friction" } + } + } + + val getCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_layer" } + } + } + + val getCollisionLayerBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_collision_layer_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_layer_bit" } + } + } + + val getCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask" } + } + } + + val getCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_mask_bit" } + } + } + + val getCollisionUseKinematic: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_collision_use_kinematic".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_use_kinematic" } + } + } + + val getCollisionUseParent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_collision_use_parent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_collision_use_parent" } + } + } + + val getCustomTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_custom_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_custom_transform" } + } + } + + val getHalfOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_half_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_half_offset" } + } + } + + val getMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mode" } + } + } + + val getOccluderLightMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_occluder_light_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_occluder_light_mask" } + } + } + + val getQuadrantSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_quadrant_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_quadrant_size" } + } + } + + val getTileOrigin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_tile_origin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tile_origin" } + } + } + + val getTileset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_tileset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tileset" } + } + } + + val getUsedCells: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_used_cells".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_used_cells" } + } + } + + val getUsedCellsById: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_used_cells_by_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_used_cells_by_id" } + } + } + + val getUsedRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "get_used_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_used_rect" } + } + } + + val isCellTransposed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "is_cell_transposed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_cell_transposed" } + } + } + + val isCellXFlipped: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "is_cell_x_flipped".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_cell_x_flipped" } + } + } + + val isCellYFlipped: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "is_cell_y_flipped".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_cell_y_flipped" } + } + } + + val isCenteredTexturesEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "is_centered_textures_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_centered_textures_enabled" } + } + } + + val isCompatibilityModeEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "is_compatibility_mode_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_compatibility_mode_enabled" + } + } + } + + val isYSortModeEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "is_y_sort_mode_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_y_sort_mode_enabled" } + } + } + + val mapToWorld: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "map_to_world".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method map_to_world" } + } + } + + val setCell: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_cell".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cell" } + } + } + + val setCellSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_cell_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cell_size" } + } + } + + val setCellv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_cellv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cellv" } + } + } + + val setCenteredTextures: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_centered_textures".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_centered_textures" } + } + } + + val setClipUv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_clip_uv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_clip_uv" } + } + } + + val setCollisionBounce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_collision_bounce".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_bounce" } + } + } + + val setCollisionFriction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_collision_friction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_friction" } + } + } + + val setCollisionLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_collision_layer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_layer" } + } + } + + val setCollisionLayerBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_collision_layer_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_layer_bit" } + } + } + + val setCollisionMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_collision_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask" } + } + } + + val setCollisionMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_collision_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_mask_bit" } + } + } + + val setCollisionUseKinematic: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_collision_use_kinematic".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_use_kinematic" } + } + } + + val setCollisionUseParent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_collision_use_parent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collision_use_parent" } + } + } + + val setCompatibilityMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_compatibility_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_compatibility_mode" } + } + } + + val setCustomTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_custom_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_custom_transform" } + } + } + + val setHalfOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_half_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_half_offset" } + } + } + + val setMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mode" } + } + } + + val setOccluderLightMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_occluder_light_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_occluder_light_mask" } + } + } + + val setQuadrantSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_quadrant_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_quadrant_size" } + } + } + + val setTileOrigin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_tile_origin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tile_origin" } + } + } + + val setTileset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_tileset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tileset" } + } + } + + val setYSortMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "set_y_sort_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_y_sort_mode" } + } + } + + val updateBitmaskArea: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "update_bitmask_area".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method update_bitmask_area" } + } + } + + val updateBitmaskRegion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "update_bitmask_region".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method update_bitmask_region" } + } + } + + val updateDirtyQuadrants: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "update_dirty_quadrants".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method update_dirty_quadrants" } + } + } + + val worldToMap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileMap".cstr.ptr, + "world_to_map".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method world_to_map" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/TileSet.kt b/godot-kotlin/src/nativeGen/kotlin/godot/TileSet.kt index 22770b2a..4ea037a8 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/TileSet.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/TileSet.kt @@ -905,397 +905,598 @@ open class TileSet( * Container for method_bind pointers for TileSet */ private object __method_bind { - val autotileClearBitmaskMap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "autotile_clear_bitmask_map".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method autotile_clear_bitmask_map" } - } - val autotileGetBitmask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "autotile_get_bitmask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method autotile_get_bitmask" } - } - val autotileGetBitmaskMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "autotile_get_bitmask_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method autotile_get_bitmask_mode" } - } - val autotileGetIconCoordinate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "autotile_get_icon_coordinate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method autotile_get_icon_coordinate" } - } - val autotileGetLightOccluder: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "autotile_get_light_occluder".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method autotile_get_light_occluder" } - } - val autotileGetNavigationPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "autotile_get_navigation_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method autotile_get_navigation_polygon" } - } - val autotileGetSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "autotile_get_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method autotile_get_size" } - } - val autotileGetSpacing: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "autotile_get_spacing".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method autotile_get_spacing" } - } - val autotileGetSubtilePriority: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "autotile_get_subtile_priority".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method autotile_get_subtile_priority" } - } - val autotileGetZIndex: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "autotile_get_z_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method autotile_get_z_index" } - } - val autotileSetBitmask: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "autotile_set_bitmask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method autotile_set_bitmask" } - } - val autotileSetBitmaskMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "autotile_set_bitmask_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method autotile_set_bitmask_mode" } - } - val autotileSetIconCoordinate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "autotile_set_icon_coordinate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method autotile_set_icon_coordinate" } - } - val autotileSetLightOccluder: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "autotile_set_light_occluder".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method autotile_set_light_occluder" } - } - val autotileSetNavigationPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "autotile_set_navigation_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method autotile_set_navigation_polygon" } - } - val autotileSetSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "autotile_set_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method autotile_set_size" } - } - val autotileSetSpacing: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "autotile_set_spacing".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method autotile_set_spacing" } - } - val autotileSetSubtilePriority: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "autotile_set_subtile_priority".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method autotile_set_subtile_priority" } - } - val autotileSetZIndex: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "autotile_set_z_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method autotile_set_z_index" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val createTile: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "create_tile".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_tile" } - } - val findTileByName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "find_tile_by_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method find_tile_by_name" } - } - val getLastUnusedTileId: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "get_last_unused_tile_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_last_unused_tile_id" } - } - val getTilesIds: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "get_tiles_ids".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tiles_ids" } - } - val removeTile: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "remove_tile".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_tile" } - } - val tileAddShape: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_add_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_add_shape" } - } - val tileGetLightOccluder: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_light_occluder".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_light_occluder" } - } - val tileGetMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_material" } - } - val tileGetModulate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_modulate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_modulate" } - } - val tileGetName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_name" } - } - val tileGetNavigationPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_navigation_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_navigation_polygon" } - } - val tileGetNavigationPolygonOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_navigation_polygon_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_navigation_polygon_offset" + val autotileClearBitmaskMap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "autotile_clear_bitmask_map".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method autotile_clear_bitmask_map" } } - } - val tileGetNormalMap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_normal_map".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_normal_map" } - } - val tileGetOccluderOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_occluder_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_occluder_offset" } - } - val tileGetRegion: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_region".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_region" } - } - val tileGetShape: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_shape" } - } - val tileGetShapeCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_shape_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_shape_count" } - } - val tileGetShapeOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_shape_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_shape_offset" } - } - val tileGetShapeOneWay: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_shape_one_way".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_shape_one_way" } - } - val tileGetShapeOneWayMargin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_shape_one_way_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_shape_one_way_margin" } - } - val tileGetShapeTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_shape_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_shape_transform" } - } - val tileGetShapes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_shapes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_shapes" } - } - val tileGetTexture: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_texture" } - } - val tileGetTextureOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_texture_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_texture_offset" } - } - val tileGetTileMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_tile_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_tile_mode" } - } - val tileGetZIndex: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_get_z_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_get_z_index" } - } - val tileSetLightOccluder: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_set_light_occluder".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_set_light_occluder" } - } - val tileSetMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_set_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_set_material" } - } - val tileSetModulate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_set_modulate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_set_modulate" } - } - val tileSetName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_set_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_set_name" } - } - val tileSetNavigationPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_set_navigation_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_set_navigation_polygon" } - } - val tileSetNavigationPolygonOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_set_navigation_polygon_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_set_navigation_polygon_offset" + } + + val autotileGetBitmask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "autotile_get_bitmask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method autotile_get_bitmask" } } - } - val tileSetNormalMap: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_set_normal_map".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_set_normal_map" } - } - val tileSetOccluderOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_set_occluder_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_set_occluder_offset" } - } - val tileSetRegion: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_set_region".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_set_region" } - } - val tileSetShape: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_set_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_set_shape" } - } - val tileSetShapeOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_set_shape_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_set_shape_offset" } - } - val tileSetShapeOneWay: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_set_shape_one_way".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_set_shape_one_way" } - } - val tileSetShapeOneWayMargin: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_set_shape_one_way_margin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_set_shape_one_way_margin" } - } - val tileSetShapeTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_set_shape_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_set_shape_transform" } - } - val tileSetShapes: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_set_shapes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_set_shapes" } - } - val tileSetTexture: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_set_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_set_texture" } - } - val tileSetTextureOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_set_texture_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_set_texture_offset" } - } - val tileSetTileMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_set_tile_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_set_tile_mode" } - } - val tileSetZIndex: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, - "tile_set_z_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tile_set_z_index" } - }} + } + + val autotileGetBitmaskMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "autotile_get_bitmask_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method autotile_get_bitmask_mode" } + } + } + + val autotileGetIconCoordinate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "autotile_get_icon_coordinate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method autotile_get_icon_coordinate" } + } + } + + val autotileGetLightOccluder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "autotile_get_light_occluder".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method autotile_get_light_occluder" } + } + } + + val autotileGetNavigationPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "autotile_get_navigation_polygon".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method autotile_get_navigation_polygon" } + } + } + + val autotileGetSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "autotile_get_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method autotile_get_size" } + } + } + + val autotileGetSpacing: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "autotile_get_spacing".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method autotile_get_spacing" } + } + } + + val autotileGetSubtilePriority: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "autotile_get_subtile_priority".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method autotile_get_subtile_priority" + } + } + } + + val autotileGetZIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "autotile_get_z_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method autotile_get_z_index" } + } + } + + val autotileSetBitmask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "autotile_set_bitmask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method autotile_set_bitmask" } + } + } + + val autotileSetBitmaskMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "autotile_set_bitmask_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method autotile_set_bitmask_mode" } + } + } + + val autotileSetIconCoordinate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "autotile_set_icon_coordinate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method autotile_set_icon_coordinate" } + } + } + + val autotileSetLightOccluder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "autotile_set_light_occluder".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method autotile_set_light_occluder" } + } + } + + val autotileSetNavigationPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "autotile_set_navigation_polygon".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method autotile_set_navigation_polygon" } + } + } + + val autotileSetSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "autotile_set_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method autotile_set_size" } + } + } + + val autotileSetSpacing: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "autotile_set_spacing".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method autotile_set_spacing" } + } + } + + val autotileSetSubtilePriority: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "autotile_set_subtile_priority".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method autotile_set_subtile_priority" + } + } + } + + val autotileSetZIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "autotile_set_z_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method autotile_set_z_index" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val createTile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "create_tile".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_tile" } + } + } + + val findTileByName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "find_tile_by_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method find_tile_by_name" } + } + } + + val getLastUnusedTileId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "get_last_unused_tile_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_last_unused_tile_id" } + } + } + + val getTilesIds: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "get_tiles_ids".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tiles_ids" } + } + } + + val removeTile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "remove_tile".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_tile" } + } + } + + val tileAddShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_add_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_add_shape" } + } + } + + val tileGetLightOccluder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_light_occluder".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_get_light_occluder" } + } + } + + val tileGetMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_get_material" } + } + } + + val tileGetModulate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_modulate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_get_modulate" } + } + } + + val tileGetName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_get_name" } + } + } + + val tileGetNavigationPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_navigation_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_get_navigation_polygon" } + } + } + + val tileGetNavigationPolygonOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_navigation_polygon_offset".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method tile_get_navigation_polygon_offset" } + } + } + + val tileGetNormalMap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_normal_map".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_get_normal_map" } + } + } + + val tileGetOccluderOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_occluder_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_get_occluder_offset" } + } + } + + val tileGetRegion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_region".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_get_region" } + } + } + + val tileGetShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_get_shape" } + } + } + + val tileGetShapeCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_shape_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_get_shape_count" } + } + } + + val tileGetShapeOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_shape_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_get_shape_offset" } + } + } + + val tileGetShapeOneWay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_shape_one_way".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_get_shape_one_way" } + } + } + + val tileGetShapeOneWayMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_shape_one_way_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_get_shape_one_way_margin" + } + } + } + + val tileGetShapeTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_shape_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_get_shape_transform" } + } + } + + val tileGetShapes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_shapes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_get_shapes" } + } + } + + val tileGetTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_get_texture" } + } + } + + val tileGetTextureOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_texture_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_get_texture_offset" } + } + } + + val tileGetTileMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_tile_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_get_tile_mode" } + } + } + + val tileGetZIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_get_z_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_get_z_index" } + } + } + + val tileSetLightOccluder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_set_light_occluder".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_set_light_occluder" } + } + } + + val tileSetMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_set_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_set_material" } + } + } + + val tileSetModulate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_set_modulate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_set_modulate" } + } + } + + val tileSetName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_set_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_set_name" } + } + } + + val tileSetNavigationPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_set_navigation_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_set_navigation_polygon" } + } + } + + val tileSetNavigationPolygonOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_set_navigation_polygon_offset".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method tile_set_navigation_polygon_offset" } + } + } + + val tileSetNormalMap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_set_normal_map".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_set_normal_map" } + } + } + + val tileSetOccluderOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_set_occluder_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_set_occluder_offset" } + } + } + + val tileSetRegion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_set_region".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_set_region" } + } + } + + val tileSetShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_set_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_set_shape" } + } + } + + val tileSetShapeOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_set_shape_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_set_shape_offset" } + } + } + + val tileSetShapeOneWay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_set_shape_one_way".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_set_shape_one_way" } + } + } + + val tileSetShapeOneWayMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_set_shape_one_way_margin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_set_shape_one_way_margin" + } + } + } + + val tileSetShapeTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_set_shape_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_set_shape_transform" } + } + } + + val tileSetShapes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_set_shapes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_set_shapes" } + } + } + + val tileSetTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_set_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_set_texture" } + } + } + + val tileSetTextureOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_set_texture_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_set_texture_offset" } + } + } + + val tileSetTileMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_set_tile_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_set_tile_mode" } + } + } + + val tileSetZIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TileSet".cstr.ptr, + "tile_set_z_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tile_set_z_index" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Timer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Timer.kt index c25ee95e..02ed7b84 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Timer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Timer.kt @@ -238,89 +238,117 @@ open class Timer( * Container for method_bind pointers for Timer */ private object __method_bind { - val getTimeLeft: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, - "get_time_left".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_time_left" } - } - val getTimerProcessMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, - "get_timer_process_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_timer_process_mode" } - } - val getWaitTime: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, - "get_wait_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_wait_time" } - } - val hasAutostart: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, - "has_autostart".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_autostart" } - } - val isOneShot: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, - "is_one_shot".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_one_shot" } - } - val isPaused: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, - "is_paused".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_paused" } - } - val isStopped: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, - "is_stopped".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_stopped" } - } - val setAutostart: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, - "set_autostart".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_autostart" } - } - val setOneShot: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, - "set_one_shot".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_one_shot" } - } - val setPaused: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, - "set_paused".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_paused" } - } - val setTimerProcessMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, - "set_timer_process_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_timer_process_mode" } - } - val setWaitTime: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, - "set_wait_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_wait_time" } - } - val start: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, - "start".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method start" } - } - val stop: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, - "stop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method stop" } - }} + val getTimeLeft: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, + "get_time_left".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_time_left" } + } + } + + val getTimerProcessMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, + "get_timer_process_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_timer_process_mode" } + } + } + + val getWaitTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, + "get_wait_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_wait_time" } + } + } + + val hasAutostart: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, + "has_autostart".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_autostart" } + } + } + + val isOneShot: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, + "is_one_shot".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_one_shot" } + } + } + + val isPaused: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, + "is_paused".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_paused" } + } + } + + val isStopped: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, + "is_stopped".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_stopped" } + } + } + + val setAutostart: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, + "set_autostart".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_autostart" } + } + } + + val setOneShot: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, + "set_one_shot".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_one_shot" } + } + } + + val setPaused: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, + "set_paused".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_paused" } + } + } + + val setTimerProcessMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, + "set_timer_process_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_timer_process_mode" } + } + } + + val setWaitTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, + "set_wait_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_wait_time" } + } + } + + val start: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, + "start".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method start" } + } + } + + val stop: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Timer".cstr.ptr, + "stop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method stop" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/TouchScreenButton.kt b/godot-kotlin/src/nativeGen/kotlin/godot/TouchScreenButton.kt index b45b25c8..2e8cf65a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/TouchScreenButton.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/TouchScreenButton.kt @@ -323,138 +323,176 @@ open class TouchScreenButton( * Container for method_bind pointers for TouchScreenButton */ private object __method_bind { - val getAction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, - "get_action".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_action" } - } - val getBitmask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, - "get_bitmask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bitmask" } - } - val getShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, - "get_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shape" } - } - val getTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, - "get_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture" } - } - val getTexturePressed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, - "get_texture_pressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture_pressed" } - } - val getVisibilityMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, - "get_visibility_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_visibility_mode" } - } - val isPassbyPressEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, - "is_passby_press_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_passby_press_enabled" } - } - val isPressed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, - "is_pressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_pressed" } - } - val isShapeCentered: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, - "is_shape_centered".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_shape_centered" } - } - val isShapeVisible: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, - "is_shape_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_shape_visible" } - } - val setAction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, - "set_action".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_action" } - } - val setBitmask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, - "set_bitmask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bitmask" } - } - val setPassbyPress: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, - "set_passby_press".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_passby_press" } - } - val setShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, - "set_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shape" } - } - val setShapeCentered: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, - "set_shape_centered".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shape_centered" } - } - val setShapeVisible: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, - "set_shape_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shape_visible" } - } - val setTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, - "set_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture" } - } - val setTexturePressed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, - "set_texture_pressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture_pressed" } - } - val setVisibilityMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, - "set_visibility_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_visibility_mode" } - }} + val getAction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, + "get_action".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_action" } + } + } + + val getBitmask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, + "get_bitmask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bitmask" } + } + } + + val getShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, + "get_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shape" } + } + } + + val getTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, + "get_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture" } + } + } + + val getTexturePressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, + "get_texture_pressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture_pressed" } + } + } + + val getVisibilityMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, + "get_visibility_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_visibility_mode" } + } + } + + val isPassbyPressEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, + "is_passby_press_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_passby_press_enabled" } + } + } + + val isPressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, + "is_pressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_pressed" } + } + } + + val isShapeCentered: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, + "is_shape_centered".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_shape_centered" } + } + } + + val isShapeVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, + "is_shape_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_shape_visible" } + } + } + + val setAction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, + "set_action".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_action" } + } + } + + val setBitmask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, + "set_bitmask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bitmask" } + } + } + + val setPassbyPress: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, + "set_passby_press".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_passby_press" } + } + } + + val setShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, + "set_shape".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shape" } + } + } + + val setShapeCentered: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, + "set_shape_centered".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shape_centered" } + } + } + + val setShapeVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, + "set_shape_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shape_visible" } + } + } + + val setTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, + "set_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture" } + } + } + + val setTexturePressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, + "set_texture_pressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture_pressed" } + } + } + + val setVisibilityMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TouchScreenButton".cstr.ptr, + "set_visibility_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_visibility_mode" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Translation.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Translation.kt index 97d62d62..78c86d49 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Translation.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Translation.kt @@ -132,54 +132,68 @@ open class Translation( * Container for method_bind pointers for Translation */ private object __method_bind { - val addMessage: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Translation".cstr.ptr, - "add_message".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_message" } - } - val eraseMessage: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Translation".cstr.ptr, - "erase_message".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method erase_message" } - } - val getLocale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Translation".cstr.ptr, - "get_locale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_locale" } - } - val getMessage: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Translation".cstr.ptr, - "get_message".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_message" } - } - val getMessageCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Translation".cstr.ptr, - "get_message_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_message_count" } - } - val getMessageList: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Translation".cstr.ptr, - "get_message_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_message_list" } - } - val setLocale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Translation".cstr.ptr, - "set_locale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_locale" } - }} + val addMessage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Translation".cstr.ptr, + "add_message".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_message" } + } + } + + val eraseMessage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Translation".cstr.ptr, + "erase_message".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method erase_message" } + } + } + + val getLocale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Translation".cstr.ptr, + "get_locale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_locale" } + } + } + + val getMessage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Translation".cstr.ptr, + "get_message".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_message" } + } + } + + val getMessageCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Translation".cstr.ptr, + "get_message_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_message_count" } + } + } + + val getMessageList: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Translation".cstr.ptr, + "get_message_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_message_list" } + } + } + + val setLocale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Translation".cstr.ptr, + "set_locale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_locale" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/TranslationServer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/TranslationServer.kt index 01c0d268..7eef37a7 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/TranslationServer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/TranslationServer.kt @@ -107,62 +107,78 @@ open class TranslationServerInternal( * Container for method_bind pointers for TranslationServer */ private object __method_bind { - val addTranslation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TranslationServer".cstr.ptr, - "add_translation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_translation" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TranslationServer".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val getLoadedLocales: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TranslationServer".cstr.ptr, - "get_loaded_locales".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_loaded_locales" } - } - val getLocale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TranslationServer".cstr.ptr, - "get_locale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_locale" } - } - val getLocaleName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TranslationServer".cstr.ptr, - "get_locale_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_locale_name" } - } - val removeTranslation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TranslationServer".cstr.ptr, - "remove_translation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_translation" } - } - val setLocale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TranslationServer".cstr.ptr, - "set_locale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_locale" } - } - val translate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TranslationServer".cstr.ptr, - "translate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method translate" } - }} + val addTranslation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TranslationServer".cstr.ptr, + "add_translation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_translation" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TranslationServer".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val getLoadedLocales: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TranslationServer".cstr.ptr, + "get_loaded_locales".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_loaded_locales" } + } + } + + val getLocale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TranslationServer".cstr.ptr, + "get_locale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_locale" } + } + } + + val getLocaleName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TranslationServer".cstr.ptr, + "get_locale_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_locale_name" } + } + } + + val removeTranslation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TranslationServer".cstr.ptr, + "remove_translation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_translation" } + } + } + + val setLocale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TranslationServer".cstr.ptr, + "set_locale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_locale" } + } + } + + val translate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TranslationServer".cstr.ptr, + "translate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method translate" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Tree.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Tree.kt index bb4a9dbd..7583661e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Tree.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Tree.kt @@ -616,227 +616,301 @@ open class Tree( * Container for method_bind pointers for Tree */ private object __method_bind { - val areColumnTitlesVisible: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "are_column_titles_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method are_column_titles_visible" } - } - val clear: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear" } - } - val createItem: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "create_item".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_item" } - } - val ensureCursorIsVisible: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "ensure_cursor_is_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method ensure_cursor_is_visible" } - } - val getAllowReselect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_allow_reselect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_allow_reselect" } - } - val getAllowRmbSelect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_allow_rmb_select".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_allow_rmb_select" } - } - val getColumnAtPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_column_at_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_column_at_position" } - } - val getColumnTitle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_column_title".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_column_title" } - } - val getColumnWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_column_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_column_width" } - } - val getColumns: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_columns".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_columns" } - } - val getCustomPopupRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_custom_popup_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_custom_popup_rect" } - } - val getDropModeFlags: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_drop_mode_flags".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_drop_mode_flags" } - } - val getDropSectionAtPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_drop_section_at_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_drop_section_at_position" } - } - val getEdited: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_edited".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_edited" } - } - val getEditedColumn: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_edited_column".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_edited_column" } - } - val getItemAreaRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_item_area_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_area_rect" } - } - val getItemAtPosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_item_at_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_item_at_position" } - } - val getNextSelected: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_next_selected".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_next_selected" } - } - val getPressedButton: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_pressed_button".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_pressed_button" } - } - val getRoot: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_root".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_root" } - } - val getScroll: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_scroll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_scroll" } - } - val getSelectMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_select_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_select_mode" } - } - val getSelected: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_selected".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_selected" } - } - val getSelectedColumn: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "get_selected_column".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_selected_column" } - } - val isFoldingHidden: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "is_folding_hidden".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_folding_hidden" } - } - val isRootHidden: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "is_root_hidden".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_root_hidden" } - } - val setAllowReselect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "set_allow_reselect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_allow_reselect" } - } - val setAllowRmbSelect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "set_allow_rmb_select".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_allow_rmb_select" } - } - val setColumnExpand: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "set_column_expand".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_column_expand" } - } - val setColumnMinWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "set_column_min_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_column_min_width" } - } - val setColumnTitle: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "set_column_title".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_column_title" } - } - val setColumnTitlesVisible: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "set_column_titles_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_column_titles_visible" } - } - val setColumns: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "set_columns".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_columns" } - } - val setDropModeFlags: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "set_drop_mode_flags".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_drop_mode_flags" } - } - val setHideFolding: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "set_hide_folding".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_hide_folding" } - } - val setHideRoot: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "set_hide_root".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_hide_root" } - } - val setSelectMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, - "set_select_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_select_mode" } - }} + val areColumnTitlesVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "are_column_titles_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method are_column_titles_visible" } + } + } + + val clear: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear" } + } + } + + val createItem: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "create_item".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_item" } + } + } + + val ensureCursorIsVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "ensure_cursor_is_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method ensure_cursor_is_visible" } + } + } + + val getAllowReselect: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_allow_reselect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_allow_reselect" } + } + } + + val getAllowRmbSelect: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_allow_rmb_select".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_allow_rmb_select" } + } + } + + val getColumnAtPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_column_at_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_column_at_position" } + } + } + + val getColumnTitle: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_column_title".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_column_title" } + } + } + + val getColumnWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_column_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_column_width" } + } + } + + val getColumns: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_columns".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_columns" } + } + } + + val getCustomPopupRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_custom_popup_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_custom_popup_rect" } + } + } + + val getDropModeFlags: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_drop_mode_flags".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_drop_mode_flags" } + } + } + + val getDropSectionAtPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_drop_section_at_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_drop_section_at_position" } + } + } + + val getEdited: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_edited".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_edited" } + } + } + + val getEditedColumn: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_edited_column".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_edited_column" } + } + } + + val getItemAreaRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_item_area_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_area_rect" } + } + } + + val getItemAtPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_item_at_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_item_at_position" } + } + } + + val getNextSelected: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_next_selected".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_next_selected" } + } + } + + val getPressedButton: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_pressed_button".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_pressed_button" } + } + } + + val getRoot: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_root".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_root" } + } + } + + val getScroll: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_scroll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_scroll" } + } + } + + val getSelectMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_select_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_select_mode" } + } + } + + val getSelected: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_selected".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_selected" } + } + } + + val getSelectedColumn: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "get_selected_column".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_selected_column" } + } + } + + val isFoldingHidden: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "is_folding_hidden".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_folding_hidden" } + } + } + + val isRootHidden: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "is_root_hidden".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_root_hidden" } + } + } + + val setAllowReselect: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "set_allow_reselect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_allow_reselect" } + } + } + + val setAllowRmbSelect: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "set_allow_rmb_select".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_allow_rmb_select" } + } + } + + val setColumnExpand: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "set_column_expand".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_column_expand" } + } + } + + val setColumnMinWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "set_column_min_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_column_min_width" } + } + } + + val setColumnTitle: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "set_column_title".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_column_title" } + } + } + + val setColumnTitlesVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "set_column_titles_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_column_titles_visible" } + } + } + + val setColumns: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "set_columns".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_columns" } + } + } + + val setDropModeFlags: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "set_drop_mode_flags".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_drop_mode_flags" } + } + } + + val setHideFolding: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "set_hide_folding".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_hide_folding" } + } + } + + val setHideRoot: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "set_hide_root".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_hide_root" } + } + } + + val setSelectMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tree".cstr.ptr, + "set_select_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_select_mode" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/TreeItem.kt b/godot-kotlin/src/nativeGen/kotlin/godot/TreeItem.kt index 9fd5d849..e30341e0 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/TreeItem.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/TreeItem.kt @@ -818,401 +818,599 @@ open class TreeItem( * Container for method_bind pointers for TreeItem */ private object __method_bind { - val addButton: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "add_button".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_button" } - } - val callRecursive: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "call_recursive".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method call_recursive" } - } - val clearCustomBgColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "clear_custom_bg_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_custom_bg_color" } - } - val clearCustomColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "clear_custom_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_custom_color" } - } - val deselect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "deselect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method deselect" } - } - val eraseButton: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "erase_button".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method erase_button" } - } - val getButton: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_button".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_button" } - } - val getButtonCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_button_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_button_count" } - } - val getButtonTooltip: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_button_tooltip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_button_tooltip" } - } - val getCellMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_cell_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cell_mode" } - } - val getChildren: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_children".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_children" } - } - val getCustomBgColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_custom_bg_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_custom_bg_color" } - } - val getCustomColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_custom_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_custom_color" } - } - val getCustomMinimumHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_custom_minimum_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_custom_minimum_height" } - } - val getExpandRight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_expand_right".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_expand_right" } - } - val getIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_icon" } - } - val getIconMaxWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_icon_max_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_icon_max_width" } - } - val getIconModulate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_icon_modulate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_icon_modulate" } - } - val getIconRegion: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_icon_region".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_icon_region" } - } - val getMetadata: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_metadata".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_metadata" } - } - val getNext: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_next".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_next" } - } - val getNextVisible: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_next_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_next_visible" } - } - val getParent: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_parent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_parent" } - } - val getPrev: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_prev".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_prev" } - } - val getPrevVisible: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_prev_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_prev_visible" } - } - val getRange: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_range".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_range" } - } - val getRangeConfig: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_range_config".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_range_config" } - } - val getText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_text" } - } - val getTextAlign: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_text_align".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_text_align" } - } - val getTooltip: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "get_tooltip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tooltip" } - } - val isButtonDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "is_button_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_button_disabled" } - } - val isChecked: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "is_checked".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_checked" } - } - val isCollapsed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "is_collapsed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_collapsed" } - } - val isCustomSetAsButton: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "is_custom_set_as_button".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_custom_set_as_button" } - } - val isEditable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "is_editable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_editable" } - } - val isFoldingDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "is_folding_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_folding_disabled" } - } - val isSelectable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "is_selectable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_selectable" } - } - val isSelected: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "is_selected".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_selected" } - } - val moveToBottom: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "move_to_bottom".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method move_to_bottom" } - } - val moveToTop: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "move_to_top".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method move_to_top" } - } - val removeChild: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "remove_child".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_child" } - } - val select: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "select".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method select" } - } - val setButton: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_button".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_button" } - } - val setButtonDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_button_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_button_disabled" } - } - val setCellMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_cell_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cell_mode" } - } - val setChecked: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_checked".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_checked" } - } - val setCollapsed: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_collapsed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_collapsed" } - } - val setCustomAsButton: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_custom_as_button".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_custom_as_button" } - } - val setCustomBgColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_custom_bg_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_custom_bg_color" } - } - val setCustomColor: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_custom_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_custom_color" } - } - val setCustomDraw: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_custom_draw".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_custom_draw" } - } - val setCustomMinimumHeight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_custom_minimum_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_custom_minimum_height" } - } - val setDisableFolding: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_disable_folding".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_disable_folding" } - } - val setEditable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_editable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_editable" } - } - val setExpandRight: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_expand_right".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_expand_right" } - } - val setIcon: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_icon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_icon" } - } - val setIconMaxWidth: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_icon_max_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_icon_max_width" } - } - val setIconModulate: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_icon_modulate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_icon_modulate" } - } - val setIconRegion: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_icon_region".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_icon_region" } - } - val setMetadata: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_metadata".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_metadata" } - } - val setRange: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_range".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_range" } - } - val setRangeConfig: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_range_config".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_range_config" } - } - val setSelectable: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_selectable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_selectable" } - } - val setText: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_text".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_text" } - } - val setTextAlign: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_text_align".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_text_align" } - } - val setTooltip: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, - "set_tooltip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tooltip" } - }} + val addButton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "add_button".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_button" } + } + } + + val callRecursive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "call_recursive".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method call_recursive" } + } + } + + val clearCustomBgColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "clear_custom_bg_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_custom_bg_color" } + } + } + + val clearCustomColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "clear_custom_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_custom_color" } + } + } + + val deselect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "deselect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method deselect" } + } + } + + val eraseButton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "erase_button".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method erase_button" } + } + } + + val getButton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_button".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_button" } + } + } + + val getButtonCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_button_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_button_count" } + } + } + + val getButtonTooltip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_button_tooltip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_button_tooltip" } + } + } + + val getCellMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_cell_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cell_mode" } + } + } + + val getChildren: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_children".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_children" } + } + } + + val getCustomBgColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_custom_bg_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_custom_bg_color" } + } + } + + val getCustomColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_custom_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_custom_color" } + } + } + + val getCustomMinimumHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_custom_minimum_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_custom_minimum_height" } + } + } + + val getExpandRight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_expand_right".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_expand_right" } + } + } + + val getIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_icon" } + } + } + + val getIconMaxWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_icon_max_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_icon_max_width" } + } + } + + val getIconModulate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_icon_modulate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_icon_modulate" } + } + } + + val getIconRegion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_icon_region".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_icon_region" } + } + } + + val getMetadata: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_metadata".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_metadata" } + } + } + + val getNext: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_next".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_next" } + } + } + + val getNextVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_next_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_next_visible" } + } + } + + val getParent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_parent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_parent" } + } + } + + val getPrev: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_prev".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_prev" } + } + } + + val getPrevVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_prev_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_prev_visible" } + } + } + + val getRange: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_range".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_range" } + } + } + + val getRangeConfig: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_range_config".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_range_config" } + } + } + + val getText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_text" } + } + } + + val getTextAlign: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_text_align".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_text_align" } + } + } + + val getTooltip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "get_tooltip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tooltip" } + } + } + + val isButtonDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "is_button_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_button_disabled" } + } + } + + val isChecked: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "is_checked".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_checked" } + } + } + + val isCollapsed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "is_collapsed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_collapsed" } + } + } + + val isCustomSetAsButton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "is_custom_set_as_button".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_custom_set_as_button" } + } + } + + val isEditable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "is_editable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_editable" } + } + } + + val isFoldingDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "is_folding_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_folding_disabled" } + } + } + + val isSelectable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "is_selectable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_selectable" } + } + } + + val isSelected: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "is_selected".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_selected" } + } + } + + val moveToBottom: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "move_to_bottom".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method move_to_bottom" } + } + } + + val moveToTop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "move_to_top".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method move_to_top" } + } + } + + val removeChild: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "remove_child".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_child" } + } + } + + val select: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "select".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method select" } + } + } + + val setButton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_button".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_button" } + } + } + + val setButtonDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_button_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_button_disabled" } + } + } + + val setCellMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_cell_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cell_mode" } + } + } + + val setChecked: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_checked".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_checked" } + } + } + + val setCollapsed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_collapsed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_collapsed" } + } + } + + val setCustomAsButton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_custom_as_button".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_custom_as_button" } + } + } + + val setCustomBgColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_custom_bg_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_custom_bg_color" } + } + } + + val setCustomColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_custom_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_custom_color" } + } + } + + val setCustomDraw: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_custom_draw".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_custom_draw" } + } + } + + val setCustomMinimumHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_custom_minimum_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_custom_minimum_height" } + } + } + + val setDisableFolding: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_disable_folding".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_disable_folding" } + } + } + + val setEditable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_editable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_editable" } + } + } + + val setExpandRight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_expand_right".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_expand_right" } + } + } + + val setIcon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_icon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_icon" } + } + } + + val setIconMaxWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_icon_max_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_icon_max_width" } + } + } + + val setIconModulate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_icon_modulate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_icon_modulate" } + } + } + + val setIconRegion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_icon_region".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_icon_region" } + } + } + + val setMetadata: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_metadata".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_metadata" } + } + } + + val setRange: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_range".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_range" } + } + } + + val setRangeConfig: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_range_config".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_range_config" } + } + } + + val setSelectable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_selectable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_selectable" } + } + } + + val setText: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_text".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_text" } + } + } + + val setTextAlign: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_text_align".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_text_align" } + } + } + + val setTooltip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("TreeItem".cstr.ptr, + "set_tooltip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tooltip" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Tween.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Tween.kt index 3ef54a65..f3306dfa 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Tween.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Tween.kt @@ -610,173 +610,230 @@ open class Tween( * Container for method_bind pointers for Tween */ private object __method_bind { - val followMethod: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "follow_method".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method follow_method" } - } - val followProperty: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "follow_property".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method follow_property" } - } - val getRuntime: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "get_runtime".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_runtime" } - } - val getSpeedScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "get_speed_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_speed_scale" } - } - val getTweenProcessMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "get_tween_process_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_tween_process_mode" } - } - val interpolateCallback: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "interpolate_callback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method interpolate_callback" } - } - val interpolateDeferredCallback: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "interpolate_deferred_callback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method interpolate_deferred_callback" } - } - val interpolateMethod: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "interpolate_method".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method interpolate_method" } - } - val interpolateProperty: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "interpolate_property".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method interpolate_property" } - } - val isActive: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "is_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_active" } - } - val isRepeat: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "is_repeat".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_repeat" } - } - val remove: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "remove".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove" } - } - val removeAll: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "remove_all".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_all" } - } - val reset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "reset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method reset" } - } - val resetAll: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "reset_all".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method reset_all" } - } - val resume: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "resume".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method resume" } - } - val resumeAll: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "resume_all".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method resume_all" } - } - val seek: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "seek".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method seek" } - } - val setActive: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "set_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_active" } - } - val setRepeat: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "set_repeat".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_repeat" } - } - val setSpeedScale: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "set_speed_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_speed_scale" } - } - val setTweenProcessMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "set_tween_process_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_tween_process_mode" } - } - val start: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "start".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method start" } - } - val stop: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "stop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method stop" } - } - val stopAll: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "stop_all".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method stop_all" } - } - val targetingMethod: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "targeting_method".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method targeting_method" } - } - val targetingProperty: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "targeting_property".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method targeting_property" } - } - val tell: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, - "tell".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method tell" } - }} + val followMethod: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "follow_method".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method follow_method" } + } + } + + val followProperty: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "follow_property".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method follow_property" } + } + } + + val getRuntime: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "get_runtime".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_runtime" } + } + } + + val getSpeedScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "get_speed_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_speed_scale" } + } + } + + val getTweenProcessMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "get_tween_process_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_tween_process_mode" } + } + } + + val interpolateCallback: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "interpolate_callback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method interpolate_callback" } + } + } + + val interpolateDeferredCallback: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "interpolate_deferred_callback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method interpolate_deferred_callback" + } + } + } + + val interpolateMethod: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "interpolate_method".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method interpolate_method" } + } + } + + val interpolateProperty: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "interpolate_property".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method interpolate_property" } + } + } + + val isActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "is_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_active" } + } + } + + val isRepeat: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "is_repeat".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_repeat" } + } + } + + val remove: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "remove".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove" } + } + } + + val removeAll: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "remove_all".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_all" } + } + } + + val reset: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "reset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method reset" } + } + } + + val resetAll: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "reset_all".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method reset_all" } + } + } + + val resume: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "resume".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method resume" } + } + } + + val resumeAll: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "resume_all".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method resume_all" } + } + } + + val seek: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "seek".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method seek" } + } + } + + val setActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "set_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_active" } + } + } + + val setRepeat: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "set_repeat".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_repeat" } + } + } + + val setSpeedScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "set_speed_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_speed_scale" } + } + } + + val setTweenProcessMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "set_tween_process_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_tween_process_mode" } + } + } + + val start: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "start".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method start" } + } + } + + val stop: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "stop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method stop" } + } + } + + val stopAll: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "stop_all".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method stop_all" } + } + } + + val targetingMethod: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "targeting_method".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method targeting_method" } + } + } + + val targetingProperty: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "targeting_property".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method targeting_property" } + } + } + + val tell: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Tween".cstr.ptr, + "tell".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method tell" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/UPNP.kt b/godot-kotlin/src/nativeGen/kotlin/godot/UPNP.kt index 34ccf7bf..2cf60573 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/UPNP.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/UPNP.kt @@ -327,107 +327,141 @@ open class UPNP( * Container for method_bind pointers for UPNP */ private object __method_bind { - val addDevice: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, - "add_device".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_device" } - } - val addPortMapping: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, - "add_port_mapping".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_port_mapping" } - } - val clearDevices: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, - "clear_devices".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_devices" } - } - val deletePortMapping: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, - "delete_port_mapping".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method delete_port_mapping" } - } - val discover: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, - "discover".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method discover" } - } - val getDevice: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, - "get_device".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_device" } - } - val getDeviceCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, - "get_device_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_device_count" } - } - val getDiscoverLocalPort: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, - "get_discover_local_port".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_discover_local_port" } - } - val getDiscoverMulticastIf: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, - "get_discover_multicast_if".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_discover_multicast_if" } - } - val getGateway: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, - "get_gateway".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_gateway" } - } - val isDiscoverIpv6: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, - "is_discover_ipv6".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_discover_ipv6" } - } - val queryExternalAddress: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, - "query_external_address".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method query_external_address" } - } - val removeDevice: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, - "remove_device".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_device" } - } - val setDevice: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, - "set_device".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_device" } - } - val setDiscoverIpv6: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, - "set_discover_ipv6".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_discover_ipv6" } - } - val setDiscoverLocalPort: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, - "set_discover_local_port".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_discover_local_port" } - } - val setDiscoverMulticastIf: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, - "set_discover_multicast_if".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_discover_multicast_if" } - }} + val addDevice: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, + "add_device".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_device" } + } + } + + val addPortMapping: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, + "add_port_mapping".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_port_mapping" } + } + } + + val clearDevices: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, + "clear_devices".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_devices" } + } + } + + val deletePortMapping: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, + "delete_port_mapping".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method delete_port_mapping" } + } + } + + val discover: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, + "discover".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method discover" } + } + } + + val getDevice: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, + "get_device".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_device" } + } + } + + val getDeviceCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, + "get_device_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_device_count" } + } + } + + val getDiscoverLocalPort: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, + "get_discover_local_port".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_discover_local_port" } + } + } + + val getDiscoverMulticastIf: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, + "get_discover_multicast_if".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_discover_multicast_if" } + } + } + + val getGateway: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, + "get_gateway".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_gateway" } + } + } + + val isDiscoverIpv6: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, + "is_discover_ipv6".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_discover_ipv6" } + } + } + + val queryExternalAddress: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, + "query_external_address".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method query_external_address" } + } + } + + val removeDevice: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, + "remove_device".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_device" } + } + } + + val setDevice: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, + "set_device".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_device" } + } + } + + val setDiscoverIpv6: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, + "set_discover_ipv6".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_discover_ipv6" } + } + } + + val setDiscoverLocalPort: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, + "set_discover_local_port".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_discover_local_port" } + } + } + + val setDiscoverMulticastIf: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNP".cstr.ptr, + "set_discover_multicast_if".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_discover_multicast_if" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/UPNPDevice.kt b/godot-kotlin/src/nativeGen/kotlin/godot/UPNPDevice.kt index 47aa04cb..fbab1d71 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/UPNPDevice.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/UPNPDevice.kt @@ -295,101 +295,149 @@ open class UPNPDevice( * Container for method_bind pointers for UPNPDevice */ private object __method_bind { - val addPortMapping: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, - "add_port_mapping".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_port_mapping" } - } - val deletePortMapping: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, - "delete_port_mapping".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method delete_port_mapping" } - } - val getDescriptionUrl: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, - "get_description_url".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_description_url" } - } - val getIgdControlUrl: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, - "get_igd_control_url".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_igd_control_url" } - } - val getIgdOurAddr: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, - "get_igd_our_addr".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_igd_our_addr" } - } - val getIgdServiceType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, - "get_igd_service_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_igd_service_type" } - } - val getIgdStatus: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, - "get_igd_status".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_igd_status" } - } - val getServiceType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, - "get_service_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_service_type" } - } - val isValidGateway: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, - "is_valid_gateway".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_valid_gateway" } - } - val queryExternalAddress: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, - "query_external_address".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method query_external_address" } - } - val setDescriptionUrl: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, - "set_description_url".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_description_url" } - } - val setIgdControlUrl: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, - "set_igd_control_url".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_igd_control_url" } - } - val setIgdOurAddr: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, - "set_igd_our_addr".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_igd_our_addr" } - } - val setIgdServiceType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, - "set_igd_service_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_igd_service_type" } - } - val setIgdStatus: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, - "set_igd_status".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_igd_status" } - } - val setServiceType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, - "set_service_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_service_type" } - }} + val addPortMapping: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, + "add_port_mapping".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_port_mapping" } + } + } + + val deletePortMapping: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, + "delete_port_mapping".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method delete_port_mapping" } + } + } + + val getDescriptionUrl: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, + "get_description_url".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_description_url" } + } + } + + val getIgdControlUrl: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, + "get_igd_control_url".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_igd_control_url" } + } + } + + val getIgdOurAddr: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, + "get_igd_our_addr".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_igd_our_addr" } + } + } + + val getIgdServiceType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, + "get_igd_service_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_igd_service_type" } + } + } + + val getIgdStatus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, + "get_igd_status".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_igd_status" } + } + } + + val getServiceType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, + "get_service_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_service_type" } + } + } + + val isValidGateway: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, + "is_valid_gateway".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_valid_gateway" } + } + } + + val queryExternalAddress: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, + "query_external_address".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method query_external_address" } + } + } + + val setDescriptionUrl: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, + "set_description_url".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_description_url" } + } + } + + val setIgdControlUrl: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, + "set_igd_control_url".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_igd_control_url" } + } + } + + val setIgdOurAddr: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, + "set_igd_our_addr".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_igd_our_addr" } + } + } + + val setIgdServiceType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, + "set_igd_service_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_igd_service_type" } + } + } + + val setIgdStatus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, + "set_igd_status".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_igd_status" } + } + } + + val setServiceType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UPNPDevice".cstr.ptr, + "set_service_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_service_type" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/UndoRedo.kt b/godot-kotlin/src/nativeGen/kotlin/godot/UndoRedo.kt index 3659fbcf..7c2cd1bb 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/UndoRedo.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/UndoRedo.kt @@ -239,101 +239,149 @@ open class UndoRedo( * Container for method_bind pointers for UndoRedo */ private object __method_bind { - val addDoMethod: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, - "add_do_method".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_do_method" } - } - val addDoProperty: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, - "add_do_property".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_do_property" } - } - val addDoReference: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, - "add_do_reference".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_do_reference" } - } - val addUndoMethod: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, - "add_undo_method".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_undo_method" } - } - val addUndoProperty: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, - "add_undo_property".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_undo_property" } - } - val addUndoReference: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, - "add_undo_reference".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_undo_reference" } - } - val clearHistory: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, - "clear_history".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_history" } - } - val commitAction: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, - "commit_action".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method commit_action" } - } - val createAction: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, - "create_action".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_action" } - } - val getCurrentActionName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, - "get_current_action_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_action_name" } - } - val getVersion: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, - "get_version".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_version" } - } - val hasRedo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, - "has_redo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_redo" } - } - val hasUndo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, - "has_undo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_undo" } - } - val isCommitingAction: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, - "is_commiting_action".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_commiting_action" } - } - val redo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, - "redo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method redo" } - } - val undo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, - "undo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method undo" } - }} + val addDoMethod: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, + "add_do_method".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_do_method" } + } + } + + val addDoProperty: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, + "add_do_property".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_do_property" } + } + } + + val addDoReference: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, + "add_do_reference".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_do_reference" } + } + } + + val addUndoMethod: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, + "add_undo_method".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_undo_method" } + } + } + + val addUndoProperty: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, + "add_undo_property".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_undo_property" } + } + } + + val addUndoReference: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, + "add_undo_reference".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_undo_reference" } + } + } + + val clearHistory: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, + "clear_history".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_history" } + } + } + + val commitAction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, + "commit_action".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method commit_action" } + } + } + + val createAction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, + "create_action".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_action" } + } + } + + val getCurrentActionName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, + "get_current_action_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_action_name" } + } + } + + val getVersion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, + "get_version".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_version" } + } + } + + val hasRedo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, + "has_redo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_redo" } + } + } + + val hasUndo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, + "has_undo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_undo" } + } + } + + val isCommitingAction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, + "is_commiting_action".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_commiting_action" } + } + } + + val redo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, + "redo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method redo" } + } + } + + val undo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("UndoRedo".cstr.ptr, + "undo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method undo" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VehicleBody.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VehicleBody.kt index fb5997aa..5c390fe6 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VehicleBody.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VehicleBody.kt @@ -123,47 +123,59 @@ open class VehicleBody( * Container for method_bind pointers for VehicleBody */ private object __method_bind { - val getBrake: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleBody".cstr.ptr, - "get_brake".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_brake" } - } - val getEngineForce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleBody".cstr.ptr, - "get_engine_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_engine_force" } - } - val getSteering: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleBody".cstr.ptr, - "get_steering".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_steering" } - } - val setBrake: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleBody".cstr.ptr, - "set_brake".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_brake" } - } - val setEngineForce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleBody".cstr.ptr, - "set_engine_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_engine_force" } - } - val setSteering: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleBody".cstr.ptr, - "set_steering".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_steering" } - }} + val getBrake: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleBody".cstr.ptr, + "get_brake".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_brake" } + } + } + + val getEngineForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleBody".cstr.ptr, + "get_engine_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_engine_force" } + } + } + + val getSteering: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleBody".cstr.ptr, + "get_steering".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_steering" } + } + } + + val setBrake: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleBody".cstr.ptr, + "set_brake".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_brake" } + } + } + + val setEngineForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleBody".cstr.ptr, + "set_engine_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_engine_force" } + } + } + + val setSteering: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleBody".cstr.ptr, + "set_steering".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_steering" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VehicleWheel.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VehicleWheel.kt index 80055a23..9e662963 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VehicleWheel.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VehicleWheel.kt @@ -429,222 +429,284 @@ open class VehicleWheel( * Container for method_bind pointers for VehicleWheel */ private object __method_bind { - val getBrake: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "get_brake".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_brake" } - } - val getDampingCompression: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "get_damping_compression".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_damping_compression" } - } - val getDampingRelaxation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "get_damping_relaxation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_damping_relaxation" } - } - val getEngineForce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "get_engine_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_engine_force" } - } - val getFrictionSlip: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "get_friction_slip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_friction_slip" } - } - val getRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "get_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_radius" } - } - val getRollInfluence: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "get_roll_influence".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_roll_influence" } - } - val getRpm: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "get_rpm".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rpm" } - } - val getSkidinfo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "get_skidinfo".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_skidinfo" } - } - val getSteering: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "get_steering".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_steering" } - } - val getSuspensionMaxForce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "get_suspension_max_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_suspension_max_force" } - } - val getSuspensionRestLength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "get_suspension_rest_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_suspension_rest_length" } - } - val getSuspensionStiffness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "get_suspension_stiffness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_suspension_stiffness" } - } - val getSuspensionTravel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "get_suspension_travel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_suspension_travel" } - } - val isInContact: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "is_in_contact".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_in_contact" } - } - val isUsedAsSteering: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "is_used_as_steering".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_used_as_steering" } - } - val isUsedAsTraction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "is_used_as_traction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_used_as_traction" } - } - val setBrake: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "set_brake".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_brake" } - } - val setDampingCompression: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "set_damping_compression".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_damping_compression" } - } - val setDampingRelaxation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "set_damping_relaxation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_damping_relaxation" } - } - val setEngineForce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "set_engine_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_engine_force" } - } - val setFrictionSlip: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "set_friction_slip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_friction_slip" } - } - val setRadius: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "set_radius".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_radius" } - } - val setRollInfluence: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "set_roll_influence".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_roll_influence" } - } - val setSteering: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "set_steering".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_steering" } - } - val setSuspensionMaxForce: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "set_suspension_max_force".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_suspension_max_force" } - } - val setSuspensionRestLength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "set_suspension_rest_length".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_suspension_rest_length" } - } - val setSuspensionStiffness: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "set_suspension_stiffness".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_suspension_stiffness" } - } - val setSuspensionTravel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "set_suspension_travel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_suspension_travel" } - } - val setUseAsSteering: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "set_use_as_steering".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_as_steering" } - } - val setUseAsTraction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, - "set_use_as_traction".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_as_traction" } - }} + val getBrake: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "get_brake".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_brake" } + } + } + + val getDampingCompression: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "get_damping_compression".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_damping_compression" } + } + } + + val getDampingRelaxation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "get_damping_relaxation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_damping_relaxation" } + } + } + + val getEngineForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "get_engine_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_engine_force" } + } + } + + val getFrictionSlip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "get_friction_slip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_friction_slip" } + } + } + + val getRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "get_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_radius" } + } + } + + val getRollInfluence: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "get_roll_influence".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_roll_influence" } + } + } + + val getRpm: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "get_rpm".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rpm" } + } + } + + val getSkidinfo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "get_skidinfo".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_skidinfo" } + } + } + + val getSteering: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "get_steering".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_steering" } + } + } + + val getSuspensionMaxForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "get_suspension_max_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_suspension_max_force" } + } + } + + val getSuspensionRestLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "get_suspension_rest_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_suspension_rest_length" } + } + } + + val getSuspensionStiffness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "get_suspension_stiffness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_suspension_stiffness" } + } + } + + val getSuspensionTravel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "get_suspension_travel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_suspension_travel" } + } + } + + val isInContact: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "is_in_contact".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_in_contact" } + } + } + + val isUsedAsSteering: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "is_used_as_steering".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_used_as_steering" } + } + } + + val isUsedAsTraction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "is_used_as_traction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_used_as_traction" } + } + } + + val setBrake: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "set_brake".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_brake" } + } + } + + val setDampingCompression: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "set_damping_compression".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_damping_compression" } + } + } + + val setDampingRelaxation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "set_damping_relaxation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_damping_relaxation" } + } + } + + val setEngineForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "set_engine_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_engine_force" } + } + } + + val setFrictionSlip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "set_friction_slip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_friction_slip" } + } + } + + val setRadius: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "set_radius".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_radius" } + } + } + + val setRollInfluence: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "set_roll_influence".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_roll_influence" } + } + } + + val setSteering: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "set_steering".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_steering" } + } + } + + val setSuspensionMaxForce: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "set_suspension_max_force".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_suspension_max_force" } + } + } + + val setSuspensionRestLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "set_suspension_rest_length".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_suspension_rest_length" } + } + } + + val setSuspensionStiffness: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "set_suspension_stiffness".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_suspension_stiffness" } + } + } + + val setSuspensionTravel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "set_suspension_travel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_suspension_travel" } + } + } + + val setUseAsSteering: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "set_use_as_steering".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_as_steering" } + } + } + + val setUseAsTraction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VehicleWheel".cstr.ptr, + "set_use_as_traction".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_as_traction" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VideoPlayer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VideoPlayer.kt index 5ab38cb8..ecaddce1 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VideoPlayer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VideoPlayer.kt @@ -355,180 +355,230 @@ open class VideoPlayer( * Container for method_bind pointers for VideoPlayer */ private object __method_bind { - val getAudioTrack: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "get_audio_track".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_audio_track" } - } - val getBufferingMsec: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "get_buffering_msec".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_buffering_msec" } - } - val getBus: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "get_bus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bus" } - } - val getStream: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "get_stream".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stream" } - } - val getStreamName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "get_stream_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stream_name" } - } - val getStreamPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "get_stream_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stream_position" } - } - val getVideoTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "get_video_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_video_texture" } - } - val getVolume: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "get_volume".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_volume" } - } - val getVolumeDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "get_volume_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_volume_db" } - } - val hasAutoplay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "has_autoplay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_autoplay" } - } - val hasExpand: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "has_expand".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_expand" } - } - val isPaused: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "is_paused".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_paused" } - } - val isPlaying: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "is_playing".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_playing" } - } - val play: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "play".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method play" } - } - val setAudioTrack: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "set_audio_track".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_audio_track" } - } - val setAutoplay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "set_autoplay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_autoplay" } - } - val setBufferingMsec: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "set_buffering_msec".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_buffering_msec" } - } - val setBus: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "set_bus".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bus" } - } - val setExpand: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "set_expand".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_expand" } - } - val setPaused: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "set_paused".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_paused" } - } - val setStream: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "set_stream".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_stream" } - } - val setStreamPosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "set_stream_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_stream_position" } - } - val setVolume: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "set_volume".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_volume" } - } - val setVolumeDb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "set_volume_db".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_volume_db" } - } - val stop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, - "stop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method stop" } - }} + val getAudioTrack: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "get_audio_track".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_audio_track" } + } + } + + val getBufferingMsec: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "get_buffering_msec".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_buffering_msec" } + } + } + + val getBus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "get_bus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bus" } + } + } + + val getStream: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "get_stream".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stream" } + } + } + + val getStreamName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "get_stream_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stream_name" } + } + } + + val getStreamPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "get_stream_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stream_position" } + } + } + + val getVideoTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "get_video_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_video_texture" } + } + } + + val getVolume: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "get_volume".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_volume" } + } + } + + val getVolumeDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "get_volume_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_volume_db" } + } + } + + val hasAutoplay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "has_autoplay".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_autoplay" } + } + } + + val hasExpand: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "has_expand".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_expand" } + } + } + + val isPaused: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "is_paused".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_paused" } + } + } + + val isPlaying: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "is_playing".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_playing" } + } + } + + val play: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "play".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method play" } + } + } + + val setAudioTrack: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "set_audio_track".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_audio_track" } + } + } + + val setAutoplay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "set_autoplay".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_autoplay" } + } + } + + val setBufferingMsec: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "set_buffering_msec".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_buffering_msec" } + } + } + + val setBus: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "set_bus".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bus" } + } + } + + val setExpand: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "set_expand".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_expand" } + } + } + + val setPaused: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "set_paused".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_paused" } + } + } + + val setStream: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "set_stream".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_stream" } + } + } + + val setStreamPosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "set_stream_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_stream_position" } + } + } + + val setVolume: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "set_volume".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_volume" } + } + } + + val setVolumeDb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "set_volume_db".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_volume_db" } + } + } + + val stop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoPlayer".cstr.ptr, + "stop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method stop" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VideoStreamGDNative.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VideoStreamGDNative.kt index ee79d67f..18fcef6b 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VideoStreamGDNative.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VideoStreamGDNative.kt @@ -74,19 +74,23 @@ open class VideoStreamGDNative( * Container for method_bind pointers for VideoStreamGDNative */ private object __method_bind { - val getFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoStreamGDNative".cstr.ptr, - "get_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_file" } - } - val setFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoStreamGDNative".cstr.ptr, - "set_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_file" } - }} + val getFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoStreamGDNative".cstr.ptr, + "get_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_file" } + } + } + + val setFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoStreamGDNative".cstr.ptr, + "set_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_file" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VideoStreamTheora.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VideoStreamTheora.kt index 140d1620..0d6c9e49 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VideoStreamTheora.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VideoStreamTheora.kt @@ -74,19 +74,23 @@ open class VideoStreamTheora( * Container for method_bind pointers for VideoStreamTheora */ private object __method_bind { - val getFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoStreamTheora".cstr.ptr, - "get_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_file" } - } - val setFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoStreamTheora".cstr.ptr, - "set_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_file" } - }} + val getFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoStreamTheora".cstr.ptr, + "get_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_file" } + } + } + + val setFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoStreamTheora".cstr.ptr, + "set_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_file" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VideoStreamWebm.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VideoStreamWebm.kt index 8f1f4232..24802893 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VideoStreamWebm.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VideoStreamWebm.kt @@ -74,19 +74,23 @@ open class VideoStreamWebm( * Container for method_bind pointers for VideoStreamWebm */ private object __method_bind { - val getFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoStreamWebm".cstr.ptr, - "get_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_file" } - } - val setFile: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoStreamWebm".cstr.ptr, - "set_file".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_file" } - }} + val getFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoStreamWebm".cstr.ptr, + "get_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_file" } + } + } + + val setFile: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VideoStreamWebm".cstr.ptr, + "set_file".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_file" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/Viewport.kt b/godot-kotlin/src/nativeGen/kotlin/godot/Viewport.kt index 9a89e563..2a7c6dbf 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/Viewport.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/Viewport.kt @@ -1240,468 +1240,704 @@ open class Viewport( * Container for method_bind pointers for Viewport */ private object __method_bind { - val findWorld: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "find_world".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method find_world" } - } - val findWorld2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "find_world_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method find_world_2d" } - } - val getCamera: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_camera".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_camera" } - } - val getCanvasTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_canvas_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_canvas_transform" } - } - val getClearMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_clear_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_clear_mode" } - } - val getDebugDraw: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_debug_draw".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_debug_draw" } - } - val getFinalTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_final_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_final_transform" } - } - val getGlobalCanvasTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_global_canvas_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_global_canvas_transform" } - } - val getHdr: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_hdr".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_hdr" } - } - val getKeep3dLinear: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_keep_3d_linear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_keep_3d_linear" } - } - val getModalStackTop: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_modal_stack_top".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_modal_stack_top" } - } - val getMousePosition: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_mouse_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_mouse_position" } - } - val getMsaa: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_msaa".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_msaa" } - } - val getPhysicsObjectPicking: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_physics_object_picking".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_physics_object_picking" } - } - val getRenderInfo: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_render_info".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_render_info" } - } - val getShadowAtlasQuadrantSubdiv: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_shadow_atlas_quadrant_subdiv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shadow_atlas_quadrant_subdiv" } - } - val getShadowAtlasSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_shadow_atlas_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_shadow_atlas_size" } - } - val getSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_size" } - } - val getSizeOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_size_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_size_override" } - } - val getTexture: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture" } - } - val getUpdateMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_update_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_update_mode" } - } - val getUsage: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_usage".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_usage" } - } - val getVflip: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_vflip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_vflip" } - } - val getViewportRid: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_viewport_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_viewport_rid" } - } - val getVisibleRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_visible_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_visible_rect" } - } - val getWorld: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_world".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_world" } - } - val getWorld2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "get_world_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_world_2d" } - } - val guiGetDragData: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "gui_get_drag_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gui_get_drag_data" } - } - val guiHasModalStack: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "gui_has_modal_stack".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gui_has_modal_stack" } - } - val guiIsDragging: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "gui_is_dragging".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gui_is_dragging" } - } - val hasTransparentBackground: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "has_transparent_background".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_transparent_background" } - } - val input: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "input".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method input" } - } - val is3dDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "is_3d_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_3d_disabled" } - } - val isAudioListener: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "is_audio_listener".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_audio_listener" } - } - val isAudioListener2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "is_audio_listener_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_audio_listener_2d" } - } - val isHandlingInputLocally: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "is_handling_input_locally".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_handling_input_locally" } - } - val isInputDisabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "is_input_disabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_input_disabled" } - } - val isInputHandled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "is_input_handled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_input_handled" } - } - val isSizeOverrideEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "is_size_override_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_size_override_enabled" } - } - val isSizeOverrideStretchEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "is_size_override_stretch_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_size_override_stretch_enabled" } - } - val isSnapControlsToPixelsEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "is_snap_controls_to_pixels_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_snap_controls_to_pixels_enabled" + val findWorld: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "find_world".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method find_world" } } - } - val isUsingOwnWorld: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "is_using_own_world".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_using_own_world" } - } - val isUsingRenderDirectToScreen: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "is_using_render_direct_to_screen".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_using_render_direct_to_screen" } - } - val setAsAudioListener: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_as_audio_listener".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_as_audio_listener" } - } - val setAsAudioListener2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_as_audio_listener_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_as_audio_listener_2d" } - } - val setAttachToScreenRect: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_attach_to_screen_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_attach_to_screen_rect" } - } - val setCanvasTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_canvas_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_canvas_transform" } - } - val setClearMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_clear_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_clear_mode" } - } - val setDebugDraw: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_debug_draw".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_debug_draw" } - } - val setDisable3d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_disable_3d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_disable_3d" } - } - val setDisableInput: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_disable_input".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_disable_input" } - } - val setGlobalCanvasTransform: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_global_canvas_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_global_canvas_transform" } - } - val setHandleInputLocally: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_handle_input_locally".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_handle_input_locally" } - } - val setHdr: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_hdr".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_hdr" } - } - val setInputAsHandled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_input_as_handled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_input_as_handled" } - } - val setKeep3dLinear: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_keep_3d_linear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_keep_3d_linear" } - } - val setMsaa: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_msaa".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_msaa" } - } - val setPhysicsObjectPicking: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_physics_object_picking".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_physics_object_picking" } - } - val setShadowAtlasQuadrantSubdiv: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_shadow_atlas_quadrant_subdiv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shadow_atlas_quadrant_subdiv" } - } - val setShadowAtlasSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_shadow_atlas_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_shadow_atlas_size" } - } - val setSize: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_size" } - } - val setSizeOverride: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_size_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_size_override" } - } - val setSizeOverrideStretch: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_size_override_stretch".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_size_override_stretch" } - } - val setSnapControlsToPixels: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_snap_controls_to_pixels".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_snap_controls_to_pixels" } - } - val setTransparentBackground: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_transparent_background".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_transparent_background" } - } - val setUpdateMode: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_update_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_update_mode" } - } - val setUsage: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_usage".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_usage" } - } - val setUseArvr: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_use_arvr".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_arvr" } - } - val setUseOwnWorld: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_use_own_world".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_own_world" } - } - val setUseRenderDirectToScreen: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_use_render_direct_to_screen".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_render_direct_to_screen" } - } - val setVflip: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_vflip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_vflip" } - } - val setWorld: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_world".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_world" } - } - val setWorld2d: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "set_world_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_world_2d" } - } - val unhandledInput: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "unhandled_input".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method unhandled_input" } - } - val updateWorlds: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "update_worlds".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method update_worlds" } - } - val useArvr: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "use_arvr".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method use_arvr" } - } - val warpMouse: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, - "warp_mouse".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method warp_mouse" } - }} + } + + val findWorld2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "find_world_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method find_world_2d" } + } + } + + val getCamera: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_camera".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_camera" } + } + } + + val getCanvasTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_canvas_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_canvas_transform" } + } + } + + val getClearMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_clear_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_clear_mode" } + } + } + + val getDebugDraw: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_debug_draw".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_debug_draw" } + } + } + + val getFinalTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_final_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_final_transform" } + } + } + + val getGlobalCanvasTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_global_canvas_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_global_canvas_transform" } + } + } + + val getHdr: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_hdr".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_hdr" } + } + } + + val getKeep3dLinear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_keep_3d_linear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_keep_3d_linear" } + } + } + + val getModalStackTop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_modal_stack_top".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_modal_stack_top" } + } + } + + val getMousePosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_mouse_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_mouse_position" } + } + } + + val getMsaa: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_msaa".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_msaa" } + } + } + + val getPhysicsObjectPicking: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_physics_object_picking".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_physics_object_picking" } + } + } + + val getRenderInfo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_render_info".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_render_info" } + } + } + + val getShadowAtlasQuadrantSubdiv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_shadow_atlas_quadrant_subdiv".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method get_shadow_atlas_quadrant_subdiv" } + } + } + + val getShadowAtlasSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_shadow_atlas_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_shadow_atlas_size" } + } + } + + val getSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_size" } + } + } + + val getSizeOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_size_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_size_override" } + } + } + + val getTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture" } + } + } + + val getUpdateMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_update_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_update_mode" } + } + } + + val getUsage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_usage".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_usage" } + } + } + + val getVflip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_vflip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_vflip" } + } + } + + val getViewportRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_viewport_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_viewport_rid" } + } + } + + val getVisibleRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_visible_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_visible_rect" } + } + } + + val getWorld: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_world".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_world" } + } + } + + val getWorld2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "get_world_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_world_2d" } + } + } + + val guiGetDragData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "gui_get_drag_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gui_get_drag_data" } + } + } + + val guiHasModalStack: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "gui_has_modal_stack".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gui_has_modal_stack" } + } + } + + val guiIsDragging: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "gui_is_dragging".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gui_is_dragging" } + } + } + + val hasTransparentBackground: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "has_transparent_background".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_transparent_background" } + } + } + + val input: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "input".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method input" } + } + } + + val is3dDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "is_3d_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_3d_disabled" } + } + } + + val isAudioListener: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "is_audio_listener".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_audio_listener" } + } + } + + val isAudioListener2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "is_audio_listener_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_audio_listener_2d" } + } + } + + val isHandlingInputLocally: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "is_handling_input_locally".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_handling_input_locally" } + } + } + + val isInputDisabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "is_input_disabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_input_disabled" } + } + } + + val isInputHandled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "is_input_handled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_input_handled" } + } + } + + val isSizeOverrideEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "is_size_override_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_size_override_enabled" } + } + } + + val isSizeOverrideStretchEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "is_size_override_stretch_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_size_override_stretch_enabled" } + } + } + + val isSnapControlsToPixelsEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "is_snap_controls_to_pixels_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_snap_controls_to_pixels_enabled" } + } + } + + val isUsingOwnWorld: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "is_using_own_world".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_using_own_world" } + } + } + + val isUsingRenderDirectToScreen: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "is_using_render_direct_to_screen".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method is_using_render_direct_to_screen" } + } + } + + val setAsAudioListener: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_as_audio_listener".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_as_audio_listener" } + } + } + + val setAsAudioListener2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_as_audio_listener_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_as_audio_listener_2d" } + } + } + + val setAttachToScreenRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_attach_to_screen_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_attach_to_screen_rect" } + } + } + + val setCanvasTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_canvas_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_canvas_transform" } + } + } + + val setClearMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_clear_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_clear_mode" } + } + } + + val setDebugDraw: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_debug_draw".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_debug_draw" } + } + } + + val setDisable3d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_disable_3d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_disable_3d" } + } + } + + val setDisableInput: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_disable_input".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_disable_input" } + } + } + + val setGlobalCanvasTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_global_canvas_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_global_canvas_transform" } + } + } + + val setHandleInputLocally: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_handle_input_locally".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_handle_input_locally" } + } + } + + val setHdr: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_hdr".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_hdr" } + } + } + + val setInputAsHandled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_input_as_handled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_input_as_handled" } + } + } + + val setKeep3dLinear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_keep_3d_linear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_keep_3d_linear" } + } + } + + val setMsaa: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_msaa".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_msaa" } + } + } + + val setPhysicsObjectPicking: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_physics_object_picking".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_physics_object_picking" } + } + } + + val setShadowAtlasQuadrantSubdiv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_shadow_atlas_quadrant_subdiv".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_shadow_atlas_quadrant_subdiv" } + } + } + + val setShadowAtlasSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_shadow_atlas_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_shadow_atlas_size" } + } + } + + val setSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_size" } + } + } + + val setSizeOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_size_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_size_override" } + } + } + + val setSizeOverrideStretch: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_size_override_stretch".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_size_override_stretch" } + } + } + + val setSnapControlsToPixels: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_snap_controls_to_pixels".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_snap_controls_to_pixels" } + } + } + + val setTransparentBackground: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_transparent_background".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_transparent_background" } + } + } + + val setUpdateMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_update_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_update_mode" } + } + } + + val setUsage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_usage".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_usage" } + } + } + + val setUseArvr: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_use_arvr".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_arvr" } + } + } + + val setUseOwnWorld: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_use_own_world".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_own_world" } + } + } + + val setUseRenderDirectToScreen: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_use_render_direct_to_screen".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method set_use_render_direct_to_screen" } + } + } + + val setVflip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_vflip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_vflip" } + } + } + + val setWorld: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_world".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_world" } + } + } + + val setWorld2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "set_world_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_world_2d" } + } + } + + val unhandledInput: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "unhandled_input".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method unhandled_input" } + } + } + + val updateWorlds: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "update_worlds".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method update_worlds" } + } + } + + val useArvr: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "use_arvr".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method use_arvr" } + } + } + + val warpMouse: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("Viewport".cstr.ptr, + "warp_mouse".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method warp_mouse" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ViewportContainer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ViewportContainer.kt index bd400ac0..9c119003 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ViewportContainer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ViewportContainer.kt @@ -100,33 +100,41 @@ open class ViewportContainer( * Container for method_bind pointers for ViewportContainer */ private object __method_bind { - val getStretchShrink: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ViewportContainer".cstr.ptr, - "get_stretch_shrink".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_stretch_shrink" } - } - val isStretchEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ViewportContainer".cstr.ptr, - "is_stretch_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_stretch_enabled" } - } - val setStretch: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ViewportContainer".cstr.ptr, - "set_stretch".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_stretch" } - } - val setStretchShrink: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ViewportContainer".cstr.ptr, - "set_stretch_shrink".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_stretch_shrink" } - }} + val getStretchShrink: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ViewportContainer".cstr.ptr, + "get_stretch_shrink".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_stretch_shrink" } + } + } + + val isStretchEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ViewportContainer".cstr.ptr, + "is_stretch_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_stretch_enabled" } + } + } + + val setStretch: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ViewportContainer".cstr.ptr, + "set_stretch".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_stretch" } + } + } + + val setStretchShrink: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ViewportContainer".cstr.ptr, + "set_stretch_shrink".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_stretch_shrink" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/ViewportTexture.kt b/godot-kotlin/src/nativeGen/kotlin/godot/ViewportTexture.kt index 96bb01cb..6bd2e5ae 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/ViewportTexture.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/ViewportTexture.kt @@ -85,19 +85,23 @@ open class ViewportTexture( * Container for method_bind pointers for ViewportTexture */ private object __method_bind { - val getViewportPathInScene: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ViewportTexture".cstr.ptr, - "get_viewport_path_in_scene".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_viewport_path_in_scene" } - } - val setViewportPathInScene: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ViewportTexture".cstr.ptr, - "set_viewport_path_in_scene".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_viewport_path_in_scene" } - }} + val getViewportPathInScene: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ViewportTexture".cstr.ptr, + "get_viewport_path_in_scene".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_viewport_path_in_scene" } + } + } + + val setViewportPathInScene: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("ViewportTexture".cstr.ptr, + "set_viewport_path_in_scene".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_viewport_path_in_scene" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisibilityEnabler.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisibilityEnabler.kt index 631bba41..ed159dc6 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisibilityEnabler.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisibilityEnabler.kt @@ -111,19 +111,23 @@ open class VisibilityEnabler( * Container for method_bind pointers for VisibilityEnabler */ private object __method_bind { - val isEnablerEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityEnabler".cstr.ptr, - "is_enabler_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_enabler_enabled" } - } - val setEnabler: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityEnabler".cstr.ptr, - "set_enabler".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_enabler" } - }} + val isEnablerEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityEnabler".cstr.ptr, + "is_enabler_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_enabler_enabled" } + } + } + + val setEnabler: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityEnabler".cstr.ptr, + "set_enabler".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_enabler" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisibilityEnabler2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisibilityEnabler2D.kt index a16b5785..17b9afff 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisibilityEnabler2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisibilityEnabler2D.kt @@ -151,19 +151,23 @@ open class VisibilityEnabler2D( * Container for method_bind pointers for VisibilityEnabler2D */ private object __method_bind { - val isEnablerEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityEnabler2D".cstr.ptr, - "is_enabler_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_enabler_enabled" } - } - val setEnabler: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityEnabler2D".cstr.ptr, - "set_enabler".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_enabler" } - }} + val isEnablerEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityEnabler2D".cstr.ptr, + "is_enabler_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_enabler_enabled" } + } + } + + val setEnabler: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityEnabler2D".cstr.ptr, + "set_enabler".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_enabler" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisibilityNotifier.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisibilityNotifier.kt index a9565613..111a8471 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisibilityNotifier.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisibilityNotifier.kt @@ -116,26 +116,32 @@ open class VisibilityNotifier( * Container for method_bind pointers for VisibilityNotifier */ private object __method_bind { - val getAabb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityNotifier".cstr.ptr, - "get_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_aabb" } - } - val isOnScreen: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityNotifier".cstr.ptr, - "is_on_screen".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_on_screen" } - } - val setAabb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityNotifier".cstr.ptr, - "set_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_aabb" } - }} + val getAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityNotifier".cstr.ptr, + "get_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_aabb" } + } + } + + val isOnScreen: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityNotifier".cstr.ptr, + "is_on_screen".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_on_screen" } + } + } + + val setAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityNotifier".cstr.ptr, + "set_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_aabb" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisibilityNotifier2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisibilityNotifier2D.kt index e615a068..0bf67713 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisibilityNotifier2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisibilityNotifier2D.kt @@ -116,26 +116,32 @@ open class VisibilityNotifier2D( * Container for method_bind pointers for VisibilityNotifier2D */ private object __method_bind { - val getRect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityNotifier2D".cstr.ptr, - "get_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rect" } - } - val isOnScreen: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityNotifier2D".cstr.ptr, - "is_on_screen".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_on_screen" } - } - val setRect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityNotifier2D".cstr.ptr, - "set_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rect" } - }} + val getRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityNotifier2D".cstr.ptr, + "get_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rect" } + } + } + + val isOnScreen: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityNotifier2D".cstr.ptr, + "is_on_screen".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_on_screen" } + } + } + + val setRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisibilityNotifier2D".cstr.ptr, + "set_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rect" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualInstance.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualInstance.kt index 27df8cf3..5b61fe1e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualInstance.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualInstance.kt @@ -145,68 +145,86 @@ open class VisualInstance( * Container for method_bind pointers for VisualInstance */ private object __method_bind { - val getAabb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualInstance".cstr.ptr, - "get_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_aabb" } - } - val getBase: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualInstance".cstr.ptr, - "get_base".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base" } - } - val getInstance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualInstance".cstr.ptr, - "get_instance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_instance" } - } - val getLayerMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualInstance".cstr.ptr, - "get_layer_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_layer_mask" } - } - val getLayerMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualInstance".cstr.ptr, - "get_layer_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_layer_mask_bit" } - } - val getTransformedAabb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualInstance".cstr.ptr, - "get_transformed_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_transformed_aabb" } - } - val setBase: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualInstance".cstr.ptr, - "set_base".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_base" } - } - val setLayerMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualInstance".cstr.ptr, - "set_layer_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_layer_mask" } - } - val setLayerMaskBit: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualInstance".cstr.ptr, - "set_layer_mask_bit".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_layer_mask_bit" } - }} + val getAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualInstance".cstr.ptr, + "get_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_aabb" } + } + } + + val getBase: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualInstance".cstr.ptr, + "get_base".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base" } + } + } + + val getInstance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualInstance".cstr.ptr, + "get_instance".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_instance" } + } + } + + val getLayerMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualInstance".cstr.ptr, + "get_layer_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_layer_mask" } + } + } + + val getLayerMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualInstance".cstr.ptr, + "get_layer_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_layer_mask_bit" } + } + } + + val getTransformedAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualInstance".cstr.ptr, + "get_transformed_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_transformed_aabb" } + } + } + + val setBase: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualInstance".cstr.ptr, + "set_base".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_base" } + } + } + + val setLayerMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualInstance".cstr.ptr, + "set_layer_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_layer_mask" } + } + } + + val setLayerMaskBit: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualInstance".cstr.ptr, + "set_layer_mask_bit".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_layer_mask_bit" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScript.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScript.kt index 73af34bc..3da9ca4b 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScript.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScript.kt @@ -585,299 +585,389 @@ open class VisualScript( * Container for method_bind pointers for VisualScript */ private object __method_bind { - val addCustomSignal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "add_custom_signal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_custom_signal" } - } - val addFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "add_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_function" } - } - val addNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "add_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_node" } - } - val addVariable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "add_variable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_variable" } - } - val customSignalAddArgument: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "custom_signal_add_argument".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method custom_signal_add_argument" } - } - val customSignalGetArgumentCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "custom_signal_get_argument_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method custom_signal_get_argument_count" } - } - val customSignalGetArgumentName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "custom_signal_get_argument_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method custom_signal_get_argument_name" } - } - val customSignalGetArgumentType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "custom_signal_get_argument_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method custom_signal_get_argument_type" } - } - val customSignalRemoveArgument: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "custom_signal_remove_argument".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method custom_signal_remove_argument" } - } - val customSignalSetArgumentName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "custom_signal_set_argument_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method custom_signal_set_argument_name" } - } - val customSignalSetArgumentType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "custom_signal_set_argument_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method custom_signal_set_argument_type" } - } - val customSignalSwapArgument: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "custom_signal_swap_argument".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method custom_signal_swap_argument" } - } - val dataConnect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "data_connect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method data_connect" } - } - val dataDisconnect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "data_disconnect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method data_disconnect" } - } - val getFunctionNodeId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "get_function_node_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_function_node_id" } - } - val getFunctionScroll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "get_function_scroll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_function_scroll" } - } - val getNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "get_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node" } - } - val getNodePosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "get_node_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_position" } - } - val getVariableDefaultValue: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "get_variable_default_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_variable_default_value" } - } - val getVariableExport: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "get_variable_export".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_variable_export" } - } - val getVariableInfo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "get_variable_info".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_variable_info" } - } - val hasCustomSignal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "has_custom_signal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_custom_signal" } - } - val hasDataConnection: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "has_data_connection".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_data_connection" } - } - val hasFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "has_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_function" } - } - val hasNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "has_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_node" } - } - val hasSequenceConnection: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "has_sequence_connection".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_sequence_connection" } - } - val hasVariable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "has_variable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_variable" } - } - val removeCustomSignal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "remove_custom_signal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_custom_signal" } - } - val removeFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "remove_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_function" } - } - val removeNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "remove_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_node" } - } - val removeVariable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "remove_variable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_variable" } - } - val renameCustomSignal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "rename_custom_signal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rename_custom_signal" } - } - val renameFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "rename_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rename_function" } - } - val renameVariable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "rename_variable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method rename_variable" } - } - val sequenceConnect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "sequence_connect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method sequence_connect" } - } - val sequenceDisconnect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "sequence_disconnect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method sequence_disconnect" } - } - val setFunctionScroll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "set_function_scroll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_function_scroll" } - } - val setInstanceBaseType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "set_instance_base_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_instance_base_type" } - } - val setNodePosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "set_node_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_node_position" } - } - val setVariableDefaultValue: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "set_variable_default_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_variable_default_value" } - } - val setVariableExport: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "set_variable_export".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_variable_export" } - } - val setVariableInfo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, - "set_variable_info".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_variable_info" } - }} + val addCustomSignal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "add_custom_signal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_custom_signal" } + } + } + + val addFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "add_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_function" } + } + } + + val addNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "add_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_node" } + } + } + + val addVariable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "add_variable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_variable" } + } + } + + val customSignalAddArgument: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "custom_signal_add_argument".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method custom_signal_add_argument" } + } + } + + val customSignalGetArgumentCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "custom_signal_get_argument_count".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method custom_signal_get_argument_count" } + } + } + + val customSignalGetArgumentName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "custom_signal_get_argument_name".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method custom_signal_get_argument_name" } + } + } + + val customSignalGetArgumentType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "custom_signal_get_argument_type".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method custom_signal_get_argument_type" } + } + } + + val customSignalRemoveArgument: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "custom_signal_remove_argument".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method custom_signal_remove_argument" + } + } + } + + val customSignalSetArgumentName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "custom_signal_set_argument_name".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method custom_signal_set_argument_name" } + } + } + + val customSignalSetArgumentType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "custom_signal_set_argument_type".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method custom_signal_set_argument_type" } + } + } + + val customSignalSwapArgument: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "custom_signal_swap_argument".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method custom_signal_swap_argument" } + } + } + + val dataConnect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "data_connect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method data_connect" } + } + } + + val dataDisconnect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "data_disconnect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method data_disconnect" } + } + } + + val getFunctionNodeId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "get_function_node_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_function_node_id" } + } + } + + val getFunctionScroll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "get_function_scroll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_function_scroll" } + } + } + + val getNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "get_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node" } + } + } + + val getNodePosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "get_node_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_position" } + } + } + + val getVariableDefaultValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "get_variable_default_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_variable_default_value" } + } + } + + val getVariableExport: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "get_variable_export".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_variable_export" } + } + } + + val getVariableInfo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "get_variable_info".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_variable_info" } + } + } + + val hasCustomSignal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "has_custom_signal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_custom_signal" } + } + } + + val hasDataConnection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "has_data_connection".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_data_connection" } + } + } + + val hasFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "has_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_function" } + } + } + + val hasNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "has_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_node" } + } + } + + val hasSequenceConnection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "has_sequence_connection".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_sequence_connection" } + } + } + + val hasVariable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "has_variable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_variable" } + } + } + + val removeCustomSignal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "remove_custom_signal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_custom_signal" } + } + } + + val removeFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "remove_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_function" } + } + } + + val removeNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "remove_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_node" } + } + } + + val removeVariable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "remove_variable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_variable" } + } + } + + val renameCustomSignal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "rename_custom_signal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rename_custom_signal" } + } + } + + val renameFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "rename_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rename_function" } + } + } + + val renameVariable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "rename_variable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method rename_variable" } + } + } + + val sequenceConnect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "sequence_connect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method sequence_connect" } + } + } + + val sequenceDisconnect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "sequence_disconnect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method sequence_disconnect" } + } + } + + val setFunctionScroll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "set_function_scroll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_function_scroll" } + } + } + + val setInstanceBaseType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "set_instance_base_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_instance_base_type" } + } + } + + val setNodePosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "set_node_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_node_position" } + } + } + + val setVariableDefaultValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "set_variable_default_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_variable_default_value" } + } + } + + val setVariableExport: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "set_variable_export".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_variable_export" } + } + } + + val setVariableInfo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScript".cstr.ptr, + "set_variable_info".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_variable_info" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptBasicTypeConstant.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptBasicTypeConstant.kt index 2d301c7e..8b86461e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptBasicTypeConstant.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptBasicTypeConstant.kt @@ -100,33 +100,41 @@ open class VisualScriptBasicTypeConstant( * Container for method_bind pointers for VisualScriptBasicTypeConstant */ private object __method_bind { - val getBasicType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptBasicTypeConstant".cstr.ptr, - "get_basic_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_basic_type" } - } - val getBasicTypeConstant: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptBasicTypeConstant".cstr.ptr, - "get_basic_type_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_basic_type_constant" } - } - val setBasicType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptBasicTypeConstant".cstr.ptr, - "set_basic_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_basic_type" } - } - val setBasicTypeConstant: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptBasicTypeConstant".cstr.ptr, - "set_basic_type_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_basic_type_constant" } - }} + val getBasicType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptBasicTypeConstant".cstr.ptr, + "get_basic_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_basic_type" } + } + } + + val getBasicTypeConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptBasicTypeConstant".cstr.ptr, + "get_basic_type_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_basic_type_constant" } + } + } + + val setBasicType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptBasicTypeConstant".cstr.ptr, + "set_basic_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_basic_type" } + } + } + + val setBasicTypeConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptBasicTypeConstant".cstr.ptr, + "set_basic_type_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_basic_type_constant" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptBuiltinFunc.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptBuiltinFunc.kt index daa1609a..3ec3a6e6 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptBuiltinFunc.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptBuiltinFunc.kt @@ -227,19 +227,23 @@ open class VisualScriptBuiltinFunc( * Container for method_bind pointers for VisualScriptBuiltinFunc */ private object __method_bind { - val getFunc: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptBuiltinFunc".cstr.ptr, - "get_func".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_func" } - } - val setFunc: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptBuiltinFunc".cstr.ptr, - "set_func".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_func" } - }} + val getFunc: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptBuiltinFunc".cstr.ptr, + "get_func".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_func" } + } + } + + val setFunc: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptBuiltinFunc".cstr.ptr, + "set_func".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_func" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptClassConstant.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptClassConstant.kt index 1ad915bf..b22e4a33 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptClassConstant.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptClassConstant.kt @@ -100,33 +100,41 @@ open class VisualScriptClassConstant( * Container for method_bind pointers for VisualScriptClassConstant */ private object __method_bind { - val getBaseType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptClassConstant".cstr.ptr, - "get_base_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base_type" } - } - val getClassConstant: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptClassConstant".cstr.ptr, - "get_class_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_class_constant" } - } - val setBaseType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptClassConstant".cstr.ptr, - "set_base_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_base_type" } - } - val setClassConstant: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptClassConstant".cstr.ptr, - "set_class_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_class_constant" } - }} + val getBaseType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptClassConstant".cstr.ptr, + "get_base_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base_type" } + } + } + + val getClassConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptClassConstant".cstr.ptr, + "get_class_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_class_constant" } + } + } + + val setBaseType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptClassConstant".cstr.ptr, + "set_base_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_base_type" } + } + } + + val setClassConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptClassConstant".cstr.ptr, + "set_class_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_class_constant" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptComment.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptComment.kt index d432abbe..6e17a90a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptComment.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptComment.kt @@ -137,47 +137,59 @@ open class VisualScriptComment( * Container for method_bind pointers for VisualScriptComment */ private object __method_bind { - val getDescription: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptComment".cstr.ptr, - "get_description".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_description" } - } - val getSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptComment".cstr.ptr, - "get_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_size" } - } - val getTitle: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptComment".cstr.ptr, - "get_title".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_title" } - } - val setDescription: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptComment".cstr.ptr, - "set_description".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_description" } - } - val setSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptComment".cstr.ptr, - "set_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_size" } - } - val setTitle: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptComment".cstr.ptr, - "set_title".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_title" } - }} + val getDescription: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptComment".cstr.ptr, + "get_description".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_description" } + } + } + + val getSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptComment".cstr.ptr, + "get_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_size" } + } + } + + val getTitle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptComment".cstr.ptr, + "get_title".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_title" } + } + } + + val setDescription: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptComment".cstr.ptr, + "set_description".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_description" } + } + } + + val setSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptComment".cstr.ptr, + "set_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_size" } + } + } + + val setTitle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptComment".cstr.ptr, + "set_title".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_title" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptConstant.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptConstant.kt index c32c36bb..81a4ef5f 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptConstant.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptConstant.kt @@ -110,33 +110,41 @@ open class VisualScriptConstant( * Container for method_bind pointers for VisualScriptConstant */ private object __method_bind { - val getConstantType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptConstant".cstr.ptr, - "get_constant_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_constant_type" } - } - val getConstantValue: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptConstant".cstr.ptr, - "get_constant_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_constant_value" } - } - val setConstantType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptConstant".cstr.ptr, - "set_constant_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_constant_type" } - } - val setConstantValue: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptConstant".cstr.ptr, - "set_constant_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_constant_value" } - }} + val getConstantType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptConstant".cstr.ptr, + "get_constant_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_constant_type" } + } + } + + val getConstantValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptConstant".cstr.ptr, + "get_constant_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_constant_value" } + } + } + + val setConstantType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptConstant".cstr.ptr, + "set_constant_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_constant_type" } + } + } + + val setConstantValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptConstant".cstr.ptr, + "set_constant_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_constant_value" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptConstructor.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptConstructor.kt index 38cf44ce..fab51779 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptConstructor.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptConstructor.kt @@ -111,33 +111,41 @@ open class VisualScriptConstructor( * Container for method_bind pointers for VisualScriptConstructor */ private object __method_bind { - val getConstructor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptConstructor".cstr.ptr, - "get_constructor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_constructor" } - } - val getConstructorType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptConstructor".cstr.ptr, - "get_constructor_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_constructor_type" } - } - val setConstructor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptConstructor".cstr.ptr, - "set_constructor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_constructor" } - } - val setConstructorType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptConstructor".cstr.ptr, - "set_constructor_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_constructor_type" } - }} + val getConstructor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptConstructor".cstr.ptr, + "get_constructor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_constructor" } + } + } + + val getConstructorType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptConstructor".cstr.ptr, + "get_constructor_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_constructor_type" } + } + } + + val setConstructor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptConstructor".cstr.ptr, + "set_constructor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_constructor" } + } + } + + val setConstructorType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptConstructor".cstr.ptr, + "set_constructor_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_constructor_type" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptDeconstruct.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptDeconstruct.kt index 8f1fb8b4..a480f940 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptDeconstruct.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptDeconstruct.kt @@ -82,19 +82,23 @@ open class VisualScriptDeconstruct( * Container for method_bind pointers for VisualScriptDeconstruct */ private object __method_bind { - val getDeconstructType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptDeconstruct".cstr.ptr, - "get_deconstruct_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_deconstruct_type" } - } - val setDeconstructType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptDeconstruct".cstr.ptr, - "set_deconstruct_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_deconstruct_type" } - }} + val getDeconstructType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptDeconstruct".cstr.ptr, + "get_deconstruct_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_deconstruct_type" } + } + } + + val setDeconstructType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptDeconstruct".cstr.ptr, + "set_deconstruct_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_deconstruct_type" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptEditor.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptEditor.kt index 28fcfbdb..d2d53854 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptEditor.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptEditor.kt @@ -65,20 +65,24 @@ open class VisualScriptEditorInternal( * Container for method_bind pointers for VisualScriptEditor */ private object __method_bind { - val addCustomNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_VisualScriptEditor".cstr.ptr, - "add_custom_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_custom_node" } - } - val removeCustomNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_VisualScriptEditor".cstr.ptr, - "remove_custom_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_custom_node" } - }} + val addCustomNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_VisualScriptEditor".cstr.ptr, + "add_custom_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_custom_node" } + } + } + + val removeCustomNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("_VisualScriptEditor".cstr.ptr, + "remove_custom_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_custom_node" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptEmitSignal.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptEmitSignal.kt index 84a740a3..31740d23 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptEmitSignal.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptEmitSignal.kt @@ -74,19 +74,23 @@ open class VisualScriptEmitSignal( * Container for method_bind pointers for VisualScriptEmitSignal */ private object __method_bind { - val getSignal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptEmitSignal".cstr.ptr, - "get_signal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_signal" } - } - val setSignal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptEmitSignal".cstr.ptr, - "set_signal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_signal" } - }} + val getSignal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptEmitSignal".cstr.ptr, + "get_signal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_signal" } + } + } + + val setSignal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptEmitSignal".cstr.ptr, + "set_signal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_signal" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptEngineSingleton.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptEngineSingleton.kt index ad968d20..3e9c5b26 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptEngineSingleton.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptEngineSingleton.kt @@ -74,19 +74,23 @@ open class VisualScriptEngineSingleton( * Container for method_bind pointers for VisualScriptEngineSingleton */ private object __method_bind { - val getSingleton: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptEngineSingleton".cstr.ptr, - "get_singleton".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_singleton" } - } - val setSingleton: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptEngineSingleton".cstr.ptr, - "set_singleton".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_singleton" } - }} + val getSingleton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptEngineSingleton".cstr.ptr, + "get_singleton".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_singleton" } + } + } + + val setSingleton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptEngineSingleton".cstr.ptr, + "set_singleton".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_singleton" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptFunctionCall.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptFunctionCall.kt index 9e77a668..fd29b32e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptFunctionCall.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptFunctionCall.kt @@ -375,145 +375,185 @@ open class VisualScriptFunctionCall( * Container for method_bind pointers for VisualScriptFunctionCall */ private object __method_bind { - val getBasePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "get_base_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base_path" } - } - val getBaseScript: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "get_base_script".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base_script" } - } - val getBaseType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "get_base_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base_type" } - } - val getBasicType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "get_basic_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_basic_type" } - } - val getCallMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "get_call_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_call_mode" } - } - val getFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "get_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_function" } - } - val getRpcCallMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "get_rpc_call_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_rpc_call_mode" } - } - val getSingleton: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "get_singleton".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_singleton" } - } - val getUseDefaultArgs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "get_use_default_args".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_use_default_args" } - } - val getValidate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "get_validate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_validate" } - } - val setBasePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "set_base_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_base_path" } - } - val setBaseScript: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "set_base_script".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_base_script" } - } - val setBaseType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "set_base_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_base_type" } - } - val setBasicType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "set_basic_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_basic_type" } - } - val setCallMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "set_call_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_call_mode" } - } - val setFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "set_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_function" } - } - val setRpcCallMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "set_rpc_call_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_rpc_call_mode" } - } - val setSingleton: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "set_singleton".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_singleton" } - } - val setUseDefaultArgs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "set_use_default_args".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_use_default_args" } - } - val setValidate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, - "set_validate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_validate" } - }} + val getBasePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "get_base_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base_path" } + } + } + + val getBaseScript: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "get_base_script".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base_script" } + } + } + + val getBaseType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "get_base_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base_type" } + } + } + + val getBasicType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "get_basic_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_basic_type" } + } + } + + val getCallMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "get_call_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_call_mode" } + } + } + + val getFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "get_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_function" } + } + } + + val getRpcCallMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "get_rpc_call_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_rpc_call_mode" } + } + } + + val getSingleton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "get_singleton".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_singleton" } + } + } + + val getUseDefaultArgs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "get_use_default_args".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_use_default_args" } + } + } + + val getValidate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "get_validate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_validate" } + } + } + + val setBasePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "set_base_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_base_path" } + } + } + + val setBaseScript: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "set_base_script".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_base_script" } + } + } + + val setBaseType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "set_base_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_base_type" } + } + } + + val setBasicType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "set_basic_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_basic_type" } + } + } + + val setCallMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "set_call_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_call_mode" } + } + } + + val setFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "set_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_function" } + } + } + + val setRpcCallMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "set_rpc_call_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_rpc_call_mode" } + } + } + + val setSingleton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "set_singleton".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_singleton" } + } + } + + val setUseDefaultArgs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "set_use_default_args".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_use_default_args" } + } + } + + val setValidate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionCall".cstr.ptr, + "set_validate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_validate" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptFunctionState.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptFunctionState.kt index 3a52177f..67e33e20 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptFunctionState.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptFunctionState.kt @@ -90,26 +90,32 @@ open class VisualScriptFunctionState( * Container for method_bind pointers for VisualScriptFunctionState */ private object __method_bind { - val connectToSignal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionState".cstr.ptr, - "connect_to_signal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method connect_to_signal" } - } - val isValid: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionState".cstr.ptr, - "is_valid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_valid" } - } - val resume: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionState".cstr.ptr, - "resume".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method resume" } - }} + val connectToSignal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionState".cstr.ptr, + "connect_to_signal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method connect_to_signal" } + } + } + + val isValid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionState".cstr.ptr, + "is_valid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_valid" } + } + } + + val resume: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptFunctionState".cstr.ptr, + "resume".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method resume" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptGlobalConstant.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptGlobalConstant.kt index 31715134..7e89859c 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptGlobalConstant.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptGlobalConstant.kt @@ -74,19 +74,23 @@ open class VisualScriptGlobalConstant( * Container for method_bind pointers for VisualScriptGlobalConstant */ private object __method_bind { - val getGlobalConstant: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptGlobalConstant".cstr.ptr, - "get_global_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_global_constant" } - } - val setGlobalConstant: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptGlobalConstant".cstr.ptr, - "set_global_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_global_constant" } - }} + val getGlobalConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptGlobalConstant".cstr.ptr, + "get_global_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_global_constant" } + } + } + + val setGlobalConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptGlobalConstant".cstr.ptr, + "set_global_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_global_constant" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptInputAction.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptInputAction.kt index 0cd4e43f..383529cc 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptInputAction.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptInputAction.kt @@ -123,33 +123,41 @@ open class VisualScriptInputAction( * Container for method_bind pointers for VisualScriptInputAction */ private object __method_bind { - val getActionMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptInputAction".cstr.ptr, - "get_action_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_action_mode" } - } - val getActionName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptInputAction".cstr.ptr, - "get_action_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_action_name" } - } - val setActionMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptInputAction".cstr.ptr, - "set_action_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_action_mode" } - } - val setActionName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptInputAction".cstr.ptr, - "set_action_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_action_name" } - }} + val getActionMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptInputAction".cstr.ptr, + "get_action_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_action_mode" } + } + } + + val getActionName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptInputAction".cstr.ptr, + "get_action_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_action_name" } + } + } + + val setActionMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptInputAction".cstr.ptr, + "set_action_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_action_mode" } + } + } + + val setActionName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptInputAction".cstr.ptr, + "set_action_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_action_name" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptLists.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptLists.kt index 74d6ba95..3bb1090f 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptLists.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptLists.kt @@ -126,61 +126,77 @@ open class VisualScriptLists( * Container for method_bind pointers for VisualScriptLists */ private object __method_bind { - val addInputDataPort: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLists".cstr.ptr, - "add_input_data_port".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_input_data_port" } - } - val addOutputDataPort: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLists".cstr.ptr, - "add_output_data_port".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_output_data_port" } - } - val removeInputDataPort: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLists".cstr.ptr, - "remove_input_data_port".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_input_data_port" } - } - val removeOutputDataPort: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLists".cstr.ptr, - "remove_output_data_port".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_output_data_port" } - } - val setInputDataPortName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLists".cstr.ptr, - "set_input_data_port_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_input_data_port_name" } - } - val setInputDataPortType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLists".cstr.ptr, - "set_input_data_port_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_input_data_port_type" } - } - val setOutputDataPortName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLists".cstr.ptr, - "set_output_data_port_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_output_data_port_name" } - } - val setOutputDataPortType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLists".cstr.ptr, - "set_output_data_port_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_output_data_port_type" } - }} + val addInputDataPort: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLists".cstr.ptr, + "add_input_data_port".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_input_data_port" } + } + } + + val addOutputDataPort: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLists".cstr.ptr, + "add_output_data_port".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_output_data_port" } + } + } + + val removeInputDataPort: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLists".cstr.ptr, + "remove_input_data_port".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_input_data_port" } + } + } + + val removeOutputDataPort: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLists".cstr.ptr, + "remove_output_data_port".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_output_data_port" } + } + } + + val setInputDataPortName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLists".cstr.ptr, + "set_input_data_port_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_input_data_port_name" } + } + } + + val setInputDataPortType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLists".cstr.ptr, + "set_input_data_port_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_input_data_port_type" } + } + } + + val setOutputDataPortName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLists".cstr.ptr, + "set_output_data_port_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_output_data_port_name" } + } + } + + val setOutputDataPortType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLists".cstr.ptr, + "set_output_data_port_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_output_data_port_type" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptLocalVar.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptLocalVar.kt index 9db7c975..91bd526a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptLocalVar.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptLocalVar.kt @@ -100,33 +100,41 @@ open class VisualScriptLocalVar( * Container for method_bind pointers for VisualScriptLocalVar */ private object __method_bind { - val getVarName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLocalVar".cstr.ptr, - "get_var_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_var_name" } - } - val getVarType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLocalVar".cstr.ptr, - "get_var_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_var_type" } - } - val setVarName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLocalVar".cstr.ptr, - "set_var_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_var_name" } - } - val setVarType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLocalVar".cstr.ptr, - "set_var_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_var_type" } - }} + val getVarName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLocalVar".cstr.ptr, + "get_var_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_var_name" } + } + } + + val getVarType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLocalVar".cstr.ptr, + "get_var_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_var_type" } + } + } + + val setVarName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLocalVar".cstr.ptr, + "set_var_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_var_name" } + } + } + + val setVarType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLocalVar".cstr.ptr, + "set_var_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_var_type" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptLocalVarSet.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptLocalVarSet.kt index 45f6a284..42de33d8 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptLocalVarSet.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptLocalVarSet.kt @@ -100,33 +100,41 @@ open class VisualScriptLocalVarSet( * Container for method_bind pointers for VisualScriptLocalVarSet */ private object __method_bind { - val getVarName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLocalVarSet".cstr.ptr, - "get_var_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_var_name" } - } - val getVarType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLocalVarSet".cstr.ptr, - "get_var_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_var_type" } - } - val setVarName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLocalVarSet".cstr.ptr, - "set_var_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_var_name" } - } - val setVarType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLocalVarSet".cstr.ptr, - "set_var_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_var_type" } - }} + val getVarName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLocalVarSet".cstr.ptr, + "get_var_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_var_name" } + } + } + + val getVarType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLocalVarSet".cstr.ptr, + "get_var_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_var_type" } + } + } + + val setVarName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLocalVarSet".cstr.ptr, + "set_var_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_var_name" } + } + } + + val setVarType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptLocalVarSet".cstr.ptr, + "set_var_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_var_type" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptMathConstant.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptMathConstant.kt index 030e5aa3..b3bf2997 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptMathConstant.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptMathConstant.kt @@ -107,19 +107,23 @@ open class VisualScriptMathConstant( * Container for method_bind pointers for VisualScriptMathConstant */ private object __method_bind { - val getMathConstant: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptMathConstant".cstr.ptr, - "get_math_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_math_constant" } - } - val setMathConstant: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptMathConstant".cstr.ptr, - "set_math_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_math_constant" } - }} + val getMathConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptMathConstant".cstr.ptr, + "get_math_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_math_constant" } + } + } + + val setMathConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptMathConstant".cstr.ptr, + "set_math_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_math_constant" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptNode.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptNode.kt index 497e14c6..b89801f1 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptNode.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptNode.kt @@ -95,33 +95,41 @@ open class VisualScriptNode( * Container for method_bind pointers for VisualScriptNode */ private object __method_bind { - val getDefaultInputValue: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptNode".cstr.ptr, - "get_default_input_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_default_input_value" } - } - val getVisualScript: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptNode".cstr.ptr, - "get_visual_script".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_visual_script" } - } - val portsChangedNotify: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptNode".cstr.ptr, - "ports_changed_notify".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method ports_changed_notify" } - } - val setDefaultInputValue: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptNode".cstr.ptr, - "set_default_input_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_default_input_value" } - }} + val getDefaultInputValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptNode".cstr.ptr, + "get_default_input_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_default_input_value" } + } + } + + val getVisualScript: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptNode".cstr.ptr, + "get_visual_script".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_visual_script" } + } + } + + val portsChangedNotify: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptNode".cstr.ptr, + "ports_changed_notify".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method ports_changed_notify" } + } + } + + val setDefaultInputValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptNode".cstr.ptr, + "set_default_input_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_default_input_value" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptOperator.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptOperator.kt index 2b98e015..eee8d7f0 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptOperator.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptOperator.kt @@ -99,33 +99,41 @@ open class VisualScriptOperator( * Container for method_bind pointers for VisualScriptOperator */ private object __method_bind { - val getOperator: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptOperator".cstr.ptr, - "get_operator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_operator" } - } - val getTyped: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptOperator".cstr.ptr, - "get_typed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_typed" } - } - val setOperator: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptOperator".cstr.ptr, - "set_operator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_operator" } - } - val setTyped: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptOperator".cstr.ptr, - "set_typed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_typed" } - }} + val getOperator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptOperator".cstr.ptr, + "get_operator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_operator" } + } + } + + val getTyped: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptOperator".cstr.ptr, + "get_typed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_typed" } + } + } + + val setOperator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptOperator".cstr.ptr, + "set_operator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_operator" } + } + } + + val setTyped: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptOperator".cstr.ptr, + "set_typed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_typed" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptPreload.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptPreload.kt index fcdea1d1..c1e3a025 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptPreload.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptPreload.kt @@ -75,19 +75,23 @@ open class VisualScriptPreload( * Container for method_bind pointers for VisualScriptPreload */ private object __method_bind { - val getPreload: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPreload".cstr.ptr, - "get_preload".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_preload" } - } - val setPreload: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPreload".cstr.ptr, - "set_preload".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_preload" } - }} + val getPreload: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPreload".cstr.ptr, + "get_preload".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_preload" } + } + } + + val setPreload: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPreload".cstr.ptr, + "set_preload".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_preload" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptPropertyGet.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptPropertyGet.kt index e2dfa7ad..25279689 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptPropertyGet.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptPropertyGet.kt @@ -269,103 +269,131 @@ open class VisualScriptPropertyGet( * Container for method_bind pointers for VisualScriptPropertyGet */ private object __method_bind { - val getBasePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, - "get_base_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base_path" } - } - val getBaseScript: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, - "get_base_script".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base_script" } - } - val getBaseType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, - "get_base_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base_type" } - } - val getBasicType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, - "get_basic_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_basic_type" } - } - val getCallMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, - "get_call_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_call_mode" } - } - val getIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, - "get_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_index" } - } - val getProperty: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, - "get_property".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_property" } - } - val setBasePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, - "set_base_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_base_path" } - } - val setBaseScript: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, - "set_base_script".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_base_script" } - } - val setBaseType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, - "set_base_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_base_type" } - } - val setBasicType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, - "set_basic_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_basic_type" } - } - val setCallMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, - "set_call_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_call_mode" } - } - val setIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, - "set_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_index" } - } - val setProperty: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, - "set_property".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_property" } - }} + val getBasePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, + "get_base_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base_path" } + } + } + + val getBaseScript: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, + "get_base_script".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base_script" } + } + } + + val getBaseType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, + "get_base_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base_type" } + } + } + + val getBasicType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, + "get_basic_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_basic_type" } + } + } + + val getCallMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, + "get_call_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_call_mode" } + } + } + + val getIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, + "get_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_index" } + } + } + + val getProperty: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, + "get_property".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_property" } + } + } + + val setBasePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, + "set_base_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_base_path" } + } + } + + val setBaseScript: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, + "set_base_script".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_base_script" } + } + } + + val setBaseType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, + "set_base_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_base_type" } + } + } + + val setBasicType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, + "set_basic_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_basic_type" } + } + } + + val setCallMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, + "set_call_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_call_mode" } + } + } + + val setIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, + "set_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_index" } + } + } + + val setProperty: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertyGet".cstr.ptr, + "set_property".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_property" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptPropertySet.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptPropertySet.kt index 27e71f6c..5e396e77 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptPropertySet.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptPropertySet.kt @@ -334,117 +334,149 @@ open class VisualScriptPropertySet( * Container for method_bind pointers for VisualScriptPropertySet */ private object __method_bind { - val getAssignOp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, - "get_assign_op".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_assign_op" } - } - val getBasePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, - "get_base_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base_path" } - } - val getBaseScript: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, - "get_base_script".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base_script" } - } - val getBaseType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, - "get_base_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base_type" } - } - val getBasicType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, - "get_basic_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_basic_type" } - } - val getCallMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, - "get_call_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_call_mode" } - } - val getIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, - "get_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_index" } - } - val getProperty: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, - "get_property".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_property" } - } - val setAssignOp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, - "set_assign_op".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_assign_op" } - } - val setBasePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, - "set_base_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_base_path" } - } - val setBaseScript: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, - "set_base_script".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_base_script" } - } - val setBaseType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, - "set_base_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_base_type" } - } - val setBasicType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, - "set_basic_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_basic_type" } - } - val setCallMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, - "set_call_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_call_mode" } - } - val setIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, - "set_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_index" } - } - val setProperty: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, - "set_property".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_property" } - }} + val getAssignOp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, + "get_assign_op".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_assign_op" } + } + } + + val getBasePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, + "get_base_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base_path" } + } + } + + val getBaseScript: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, + "get_base_script".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base_script" } + } + } + + val getBaseType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, + "get_base_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base_type" } + } + } + + val getBasicType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, + "get_basic_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_basic_type" } + } + } + + val getCallMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, + "get_call_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_call_mode" } + } + } + + val getIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, + "get_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_index" } + } + } + + val getProperty: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, + "get_property".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_property" } + } + } + + val setAssignOp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, + "set_assign_op".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_assign_op" } + } + } + + val setBasePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, + "set_base_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_base_path" } + } + } + + val setBaseScript: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, + "set_base_script".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_base_script" } + } + } + + val setBaseType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, + "set_base_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_base_type" } + } + } + + val setBasicType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, + "set_basic_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_basic_type" } + } + } + + val setCallMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, + "set_call_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_call_mode" } + } + } + + val setIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, + "set_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_index" } + } + } + + val setProperty: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptPropertySet".cstr.ptr, + "set_property".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_property" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptResourcePath.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptResourcePath.kt index 1fd79373..8f06158b 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptResourcePath.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptResourcePath.kt @@ -74,19 +74,23 @@ open class VisualScriptResourcePath( * Container for method_bind pointers for VisualScriptResourcePath */ private object __method_bind { - val getResourcePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptResourcePath".cstr.ptr, - "get_resource_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_resource_path" } - } - val setResourcePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptResourcePath".cstr.ptr, - "set_resource_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_resource_path" } - }} + val getResourcePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptResourcePath".cstr.ptr, + "get_resource_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_resource_path" } + } + } + + val setResourcePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptResourcePath".cstr.ptr, + "set_resource_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_resource_path" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptReturn.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptReturn.kt index 81c8c9fe..dfcc1aa5 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptReturn.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptReturn.kt @@ -100,33 +100,41 @@ open class VisualScriptReturn( * Container for method_bind pointers for VisualScriptReturn */ private object __method_bind { - val getReturnType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptReturn".cstr.ptr, - "get_return_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_return_type" } - } - val isReturnValueEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptReturn".cstr.ptr, - "is_return_value_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_return_value_enabled" } - } - val setEnableReturnValue: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptReturn".cstr.ptr, - "set_enable_return_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_enable_return_value" } - } - val setReturnType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptReturn".cstr.ptr, - "set_return_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_return_type" } - }} + val getReturnType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptReturn".cstr.ptr, + "get_return_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_return_type" } + } + } + + val isReturnValueEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptReturn".cstr.ptr, + "is_return_value_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_return_value_enabled" } + } + } + + val setEnableReturnValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptReturn".cstr.ptr, + "set_enable_return_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_enable_return_value" } + } + } + + val setReturnType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptReturn".cstr.ptr, + "set_return_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_return_type" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptSceneNode.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptSceneNode.kt index a768a941..6c24aa89 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptSceneNode.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptSceneNode.kt @@ -85,19 +85,23 @@ open class VisualScriptSceneNode( * Container for method_bind pointers for VisualScriptSceneNode */ private object __method_bind { - val getNodePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptSceneNode".cstr.ptr, - "get_node_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_path" } - } - val setNodePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptSceneNode".cstr.ptr, - "set_node_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_node_path" } - }} + val getNodePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptSceneNode".cstr.ptr, + "get_node_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_path" } + } + } + + val setNodePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptSceneNode".cstr.ptr, + "set_node_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_node_path" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptSelect.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptSelect.kt index 1891a1a4..e5cffd17 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptSelect.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptSelect.kt @@ -74,19 +74,23 @@ open class VisualScriptSelect( * Container for method_bind pointers for VisualScriptSelect */ private object __method_bind { - val getTyped: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptSelect".cstr.ptr, - "get_typed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_typed" } - } - val setTyped: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptSelect".cstr.ptr, - "set_typed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_typed" } - }} + val getTyped: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptSelect".cstr.ptr, + "get_typed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_typed" } + } + } + + val setTyped: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptSelect".cstr.ptr, + "set_typed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_typed" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptSequence.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptSequence.kt index 9a06affc..3e261635 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptSequence.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptSequence.kt @@ -74,19 +74,23 @@ open class VisualScriptSequence( * Container for method_bind pointers for VisualScriptSequence */ private object __method_bind { - val getSteps: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptSequence".cstr.ptr, - "get_steps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_steps" } - } - val setSteps: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptSequence".cstr.ptr, - "set_steps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_steps" } - }} + val getSteps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptSequence".cstr.ptr, + "get_steps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_steps" } + } + } + + val setSteps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptSequence".cstr.ptr, + "set_steps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_steps" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptTypeCast.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptTypeCast.kt index e3941a43..3d878c56 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptTypeCast.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptTypeCast.kt @@ -100,33 +100,41 @@ open class VisualScriptTypeCast( * Container for method_bind pointers for VisualScriptTypeCast */ private object __method_bind { - val getBaseScript: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptTypeCast".cstr.ptr, - "get_base_script".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base_script" } - } - val getBaseType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptTypeCast".cstr.ptr, - "get_base_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base_type" } - } - val setBaseScript: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptTypeCast".cstr.ptr, - "set_base_script".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_base_script" } - } - val setBaseType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptTypeCast".cstr.ptr, - "set_base_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_base_type" } - }} + val getBaseScript: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptTypeCast".cstr.ptr, + "get_base_script".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base_script" } + } + } + + val getBaseType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptTypeCast".cstr.ptr, + "get_base_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base_type" } + } + } + + val setBaseScript: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptTypeCast".cstr.ptr, + "set_base_script".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_base_script" } + } + } + + val setBaseType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptTypeCast".cstr.ptr, + "set_base_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_base_type" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptVariableGet.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptVariableGet.kt index 93a2c9a6..58c93a57 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptVariableGet.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptVariableGet.kt @@ -74,19 +74,23 @@ open class VisualScriptVariableGet( * Container for method_bind pointers for VisualScriptVariableGet */ private object __method_bind { - val getVariable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptVariableGet".cstr.ptr, - "get_variable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_variable" } - } - val setVariable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptVariableGet".cstr.ptr, - "set_variable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_variable" } - }} + val getVariable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptVariableGet".cstr.ptr, + "get_variable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_variable" } + } + } + + val setVariable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptVariableGet".cstr.ptr, + "set_variable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_variable" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptVariableSet.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptVariableSet.kt index 0ff87cd9..55702de8 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptVariableSet.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptVariableSet.kt @@ -74,19 +74,23 @@ open class VisualScriptVariableSet( * Container for method_bind pointers for VisualScriptVariableSet */ private object __method_bind { - val getVariable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptVariableSet".cstr.ptr, - "get_variable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_variable" } - } - val setVariable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptVariableSet".cstr.ptr, - "set_variable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_variable" } - }} + val getVariable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptVariableSet".cstr.ptr, + "get_variable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_variable" } + } + } + + val setVariable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptVariableSet".cstr.ptr, + "set_variable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_variable" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptYield.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptYield.kt index efecf1b5..8f42c037 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptYield.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptYield.kt @@ -121,33 +121,41 @@ open class VisualScriptYield( * Container for method_bind pointers for VisualScriptYield */ private object __method_bind { - val getWaitTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYield".cstr.ptr, - "get_wait_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_wait_time" } - } - val getYieldMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYield".cstr.ptr, - "get_yield_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_yield_mode" } - } - val setWaitTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYield".cstr.ptr, - "set_wait_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_wait_time" } - } - val setYieldMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYield".cstr.ptr, - "set_yield_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_yield_mode" } - }} + val getWaitTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYield".cstr.ptr, + "get_wait_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_wait_time" } + } + } + + val getYieldMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYield".cstr.ptr, + "get_yield_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_yield_mode" } + } + } + + val setWaitTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYield".cstr.ptr, + "set_wait_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_wait_time" } + } + } + + val setYieldMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYield".cstr.ptr, + "set_yield_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_yield_mode" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptYieldSignal.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptYieldSignal.kt index d75f5e48..3fe89462 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptYieldSignal.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualScriptYieldSignal.kt @@ -184,61 +184,77 @@ open class VisualScriptYieldSignal( * Container for method_bind pointers for VisualScriptYieldSignal */ private object __method_bind { - val getBasePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYieldSignal".cstr.ptr, - "get_base_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base_path" } - } - val getBaseType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYieldSignal".cstr.ptr, - "get_base_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_base_type" } - } - val getCallMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYieldSignal".cstr.ptr, - "get_call_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_call_mode" } - } - val getSignal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYieldSignal".cstr.ptr, - "get_signal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_signal" } - } - val setBasePath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYieldSignal".cstr.ptr, - "set_base_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_base_path" } - } - val setBaseType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYieldSignal".cstr.ptr, - "set_base_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_base_type" } - } - val setCallMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYieldSignal".cstr.ptr, - "set_call_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_call_mode" } - } - val setSignal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYieldSignal".cstr.ptr, - "set_signal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_signal" } - }} + val getBasePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYieldSignal".cstr.ptr, + "get_base_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base_path" } + } + } + + val getBaseType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYieldSignal".cstr.ptr, + "get_base_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_base_type" } + } + } + + val getCallMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYieldSignal".cstr.ptr, + "get_call_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_call_mode" } + } + } + + val getSignal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYieldSignal".cstr.ptr, + "get_signal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_signal" } + } + } + + val setBasePath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYieldSignal".cstr.ptr, + "set_base_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_base_path" } + } + } + + val setBaseType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYieldSignal".cstr.ptr, + "set_base_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_base_type" } + } + } + + val setCallMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYieldSignal".cstr.ptr, + "set_call_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_call_mode" } + } + } + + val setSignal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualScriptYieldSignal".cstr.ptr, + "set_signal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_signal" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualServer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualServer.kt index e169cfbb..453b53d5 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualServer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualServer.kt @@ -4447,2613 +4447,3390 @@ open class VisualServerInternal( * Container for method_bind pointers for VisualServer */ private object __method_bind { - val blackBarsSetImages: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "black_bars_set_images".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method black_bars_set_images" } - } - val blackBarsSetMargins: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "black_bars_set_margins".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method black_bars_set_margins" } - } - val cameraCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "camera_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method camera_create" } - } - val cameraSetCullMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "camera_set_cull_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method camera_set_cull_mask" } - } - val cameraSetEnvironment: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "camera_set_environment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method camera_set_environment" } - } - val cameraSetFrustum: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "camera_set_frustum".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method camera_set_frustum" } - } - val cameraSetOrthogonal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "camera_set_orthogonal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method camera_set_orthogonal" } - } - val cameraSetPerspective: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "camera_set_perspective".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method camera_set_perspective" } - } - val cameraSetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "camera_set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method camera_set_transform" } - } - val cameraSetUseVerticalAspect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "camera_set_use_vertical_aspect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method camera_set_use_vertical_aspect" } - } - val canvasCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_create" } - } - val canvasItemAddCircle: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_add_circle".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_add_circle" } - } - val canvasItemAddClipIgnore: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_add_clip_ignore".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_add_clip_ignore" } - } - val canvasItemAddLine: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_add_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_add_line" } - } - val canvasItemAddMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_add_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_add_mesh" } - } - val canvasItemAddMultimesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_add_multimesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_add_multimesh" } - } - val canvasItemAddNinePatch: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_add_nine_patch".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_add_nine_patch" } - } - val canvasItemAddParticles: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_add_particles".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_add_particles" } - } - val canvasItemAddPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_add_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_add_polygon" } - } - val canvasItemAddPolyline: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_add_polyline".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_add_polyline" } - } - val canvasItemAddPrimitive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_add_primitive".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_add_primitive" } - } - val canvasItemAddRect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_add_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_add_rect" } - } - val canvasItemAddSetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_add_set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_add_set_transform" } - } - val canvasItemAddTextureRect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_add_texture_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_add_texture_rect" } - } - val canvasItemAddTextureRectRegion: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_add_texture_rect_region".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method canvas_item_add_texture_rect_region" } - } - val canvasItemAddTriangleArray: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_add_triangle_array".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_add_triangle_array" } - } - val canvasItemClear: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_clear" } - } - val canvasItemCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_create" } - } - val canvasItemSetClip: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_set_clip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_set_clip" } - } - val canvasItemSetCopyToBackbuffer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_set_copy_to_backbuffer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_set_copy_to_backbuffer" + val blackBarsSetImages: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "black_bars_set_images".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method black_bars_set_images" } + } + } + + val blackBarsSetMargins: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "black_bars_set_margins".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method black_bars_set_margins" } + } + } + + val cameraCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "camera_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method camera_create" } + } + } + + val cameraSetCullMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "camera_set_cull_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method camera_set_cull_mask" } + } + } + + val cameraSetEnvironment: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "camera_set_environment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method camera_set_environment" } + } + } + + val cameraSetFrustum: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "camera_set_frustum".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method camera_set_frustum" } + } + } + + val cameraSetOrthogonal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "camera_set_orthogonal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method camera_set_orthogonal" } + } + } + + val cameraSetPerspective: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "camera_set_perspective".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method camera_set_perspective" } + } + } + + val cameraSetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "camera_set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method camera_set_transform" } + } + } + + val cameraSetUseVerticalAspect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "camera_set_use_vertical_aspect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method camera_set_use_vertical_aspect" + } + } + } + + val canvasCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_create" } + } + } + + val canvasItemAddCircle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_add_circle".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_add_circle" } + } + } + + val canvasItemAddClipIgnore: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_add_clip_ignore".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_add_clip_ignore" } + } + } + + val canvasItemAddLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_add_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_add_line" } + } + } + + val canvasItemAddMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_add_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_add_mesh" } + } + } + + val canvasItemAddMultimesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_add_multimesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_add_multimesh" } + } + } + + val canvasItemAddNinePatch: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_add_nine_patch".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_add_nine_patch" } + } + } + + val canvasItemAddParticles: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_add_particles".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_add_particles" } + } + } + + val canvasItemAddPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_add_polygon".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_add_polygon" } + } + } + + val canvasItemAddPolyline: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_add_polyline".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_add_polyline" } + } + } + + val canvasItemAddPrimitive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_add_primitive".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_add_primitive" } + } + } + + val canvasItemAddRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_add_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_add_rect" } + } + } + + val canvasItemAddSetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_add_set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_add_set_transform" + } + } + } + + val canvasItemAddTextureRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_add_texture_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_add_texture_rect" } + } + } + + val canvasItemAddTextureRectRegion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_add_texture_rect_region".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_item_add_texture_rect_region" } + } + } + + val canvasItemAddTriangleArray: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_add_triangle_array".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_add_triangle_array" + } + } + } + + val canvasItemClear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_clear" } + } + } + + val canvasItemCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_create" } + } + } + + val canvasItemSetClip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_set_clip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_set_clip" } + } + } + + val canvasItemSetCopyToBackbuffer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_set_copy_to_backbuffer".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_item_set_copy_to_backbuffer" } + } + } + + val canvasItemSetCustomRect: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_set_custom_rect".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_set_custom_rect" } + } + } + + val canvasItemSetDistanceFieldMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_set_distance_field_mode".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_item_set_distance_field_mode" } + } + } + + val canvasItemSetDrawBehindParent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_set_draw_behind_parent".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_item_set_draw_behind_parent" } + } + } + + val canvasItemSetDrawIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_set_draw_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_set_draw_index" } + } + } + + val canvasItemSetLightMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_set_light_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_set_light_mask" } + } + } + + val canvasItemSetMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_set_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_set_material" } + } + } + + val canvasItemSetModulate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_set_modulate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_set_modulate" } + } + } + + val canvasItemSetParent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_set_parent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_set_parent" } + } + } + + val canvasItemSetSelfModulate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_set_self_modulate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_set_self_modulate" + } + } + } + + val canvasItemSetSortChildrenByY: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_set_sort_children_by_y".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_item_set_sort_children_by_y" } + } + } + + val canvasItemSetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_set_transform" } + } + } + + val canvasItemSetUseParentMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_set_use_parent_material".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_item_set_use_parent_material" } + } + } + + val canvasItemSetVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_set_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_set_visible" } + } + } + + val canvasItemSetZAsRelativeToParent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_set_z_as_relative_to_parent".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_item_set_z_as_relative_to_parent" } + } + } + + val canvasItemSetZIndex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_item_set_z_index".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_item_set_z_index" } + } + } + + val canvasLightAttachToCanvas: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_attach_to_canvas".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_light_attach_to_canvas" + } + } + } + + val canvasLightCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_light_create" } + } + } + + val canvasLightOccluderAttachToCanvas: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_occluder_attach_to_canvas".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_light_occluder_attach_to_canvas" } + } + } + + val canvasLightOccluderCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_occluder_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_light_occluder_create" } + } + } + + val canvasLightOccluderSetEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_occluder_set_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_light_occluder_set_enabled" } + } + } + + val canvasLightOccluderSetLightMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_occluder_set_light_mask".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_light_occluder_set_light_mask" } + } + } + + val canvasLightOccluderSetPolygon: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_occluder_set_polygon".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_light_occluder_set_polygon" } + } + } + + val canvasLightOccluderSetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_occluder_set_transform".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_light_occluder_set_transform" } + } + } + + val canvasLightSetColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_set_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_light_set_color" } + } + } + + val canvasLightSetEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_set_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_light_set_enabled" } + } + } + + val canvasLightSetEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_set_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_light_set_energy" } + } + } + + val canvasLightSetHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_set_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_light_set_height" } + } + } + + val canvasLightSetItemCullMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_set_item_cull_mask".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_light_set_item_cull_mask" } + } + } + + val canvasLightSetItemShadowCullMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_set_item_shadow_cull_mask".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_light_set_item_shadow_cull_mask" } + } + } + + val canvasLightSetLayerRange: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_set_layer_range".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_light_set_layer_range" } + } + } + + val canvasLightSetMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_set_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_light_set_mode" } + } + } + + val canvasLightSetScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_set_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_light_set_scale" } + } + } + + val canvasLightSetShadowBufferSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_set_shadow_buffer_size".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_light_set_shadow_buffer_size" } + } + } + + val canvasLightSetShadowColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_set_shadow_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_light_set_shadow_color" + } + } + } + + val canvasLightSetShadowEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_set_shadow_enabled".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_light_set_shadow_enabled" } + } + } + + val canvasLightSetShadowFilter: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_set_shadow_filter".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_light_set_shadow_filter" + } + } + } + + val canvasLightSetShadowGradientLength: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_set_shadow_gradient_length".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_light_set_shadow_gradient_length" } + } + } + + val canvasLightSetShadowSmooth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_set_shadow_smooth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_light_set_shadow_smooth" + } + } + } + + val canvasLightSetTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_set_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_light_set_texture" } + } + } + + val canvasLightSetTextureOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_set_texture_offset".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_light_set_texture_offset" } + } + } + + val canvasLightSetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_light_set_transform" } + } + } + + val canvasLightSetZRange: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_light_set_z_range".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_light_set_z_range" } + } + } + + val canvasOccluderPolygonCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_occluder_polygon_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_occluder_polygon_create" + } + } + } + + val canvasOccluderPolygonSetCullMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_occluder_polygon_set_cull_mode".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_occluder_polygon_set_cull_mode" } + } + } + + val canvasOccluderPolygonSetShape: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_occluder_polygon_set_shape".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_occluder_polygon_set_shape" } + } + } + + val canvasOccluderPolygonSetShapeAsLines: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_occluder_polygon_set_shape_as_lines".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method canvas_occluder_polygon_set_shape_as_lines" } + } + } + + val canvasSetItemMirroring: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_set_item_mirroring".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_set_item_mirroring" } + } + } + + val canvasSetModulate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "canvas_set_modulate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method canvas_set_modulate" } + } + } + + val directionalLightCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "directional_light_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method directional_light_create" } + } + } + + val draw: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "draw".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method draw" } + } + } + + val environmentCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "environment_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method environment_create" } + } + } + + val environmentSetAdjustment: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "environment_set_adjustment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method environment_set_adjustment" } + } + } + + val environmentSetAmbientLight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "environment_set_ambient_light".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method environment_set_ambient_light" + } + } + } + + val environmentSetBackground: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "environment_set_background".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method environment_set_background" } + } + } + + val environmentSetBgColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "environment_set_bg_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method environment_set_bg_color" } + } + } + + val environmentSetBgEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "environment_set_bg_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method environment_set_bg_energy" } + } + } + + val environmentSetCanvasMaxLayer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "environment_set_canvas_max_layer".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method environment_set_canvas_max_layer" } + } + } + + val environmentSetDofBlurFar: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "environment_set_dof_blur_far".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method environment_set_dof_blur_far" } + } + } + + val environmentSetDofBlurNear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "environment_set_dof_blur_near".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method environment_set_dof_blur_near" + } + } + } + + val environmentSetFog: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "environment_set_fog".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method environment_set_fog" } + } + } + + val environmentSetFogDepth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "environment_set_fog_depth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method environment_set_fog_depth" } + } + } + + val environmentSetFogHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "environment_set_fog_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method environment_set_fog_height" } + } + } + + val environmentSetGlow: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "environment_set_glow".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method environment_set_glow" } + } + } + + val environmentSetSky: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "environment_set_sky".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method environment_set_sky" } + } + } + + val environmentSetSkyCustomFov: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "environment_set_sky_custom_fov".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method environment_set_sky_custom_fov" + } + } + } + + val environmentSetSkyOrientation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "environment_set_sky_orientation".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method environment_set_sky_orientation" } + } + } + + val environmentSetSsao: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "environment_set_ssao".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method environment_set_ssao" } + } + } + + val environmentSetSsr: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "environment_set_ssr".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method environment_set_ssr" } + } + } + + val environmentSetTonemap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "environment_set_tonemap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method environment_set_tonemap" } + } + } + + val finish: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "finish".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method finish" } + } + } + + val forceDraw: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "force_draw".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method force_draw" } + } + } + + val forceSync: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "force_sync".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method force_sync" } + } + } + + val freeRid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "free_rid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method free_rid" } + } + } + + val getRenderInfo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "get_render_info".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_render_info" } + } + } + + val getTestCube: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "get_test_cube".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_test_cube" } + } + } + + val getTestTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "get_test_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_test_texture" } + } + } + + val getVideoAdapterName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "get_video_adapter_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_video_adapter_name" } + } + } + + val getVideoAdapterVendor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "get_video_adapter_vendor".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_video_adapter_vendor" } + } + } + + val getWhiteTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "get_white_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_white_texture" } + } + } + + val giProbeCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_create" } + } + } + + val giProbeGetBias: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_get_bias".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_get_bias" } + } + } + + val giProbeGetBounds: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_get_bounds".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_get_bounds" } + } + } + + val giProbeGetCellSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_get_cell_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_get_cell_size" } + } + } + + val giProbeGetDynamicData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_get_dynamic_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_get_dynamic_data" } + } + } + + val giProbeGetDynamicRange: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_get_dynamic_range".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_get_dynamic_range" } + } + } + + val giProbeGetEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_get_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_get_energy" } + } + } + + val giProbeGetNormalBias: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_get_normal_bias".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_get_normal_bias" } + } + } + + val giProbeGetPropagation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_get_propagation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_get_propagation" } + } + } + + val giProbeGetToCellXform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_get_to_cell_xform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_get_to_cell_xform" } + } + } + + val giProbeIsCompressed: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_is_compressed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_is_compressed" } + } + } + + val giProbeIsInterior: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_is_interior".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_is_interior" } + } + } + + val giProbeSetBias: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_set_bias".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_set_bias" } + } + } + + val giProbeSetBounds: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_set_bounds".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_set_bounds" } + } + } + + val giProbeSetCellSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_set_cell_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_set_cell_size" } + } + } + + val giProbeSetCompress: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_set_compress".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_set_compress" } + } + } + + val giProbeSetDynamicData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_set_dynamic_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_set_dynamic_data" } + } + } + + val giProbeSetDynamicRange: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_set_dynamic_range".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_set_dynamic_range" } + } + } + + val giProbeSetEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_set_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_set_energy" } + } + } + + val giProbeSetInterior: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_set_interior".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_set_interior" } + } + } + + val giProbeSetNormalBias: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_set_normal_bias".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_set_normal_bias" } + } + } + + val giProbeSetPropagation: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_set_propagation".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_set_propagation" } + } + } + + val giProbeSetToCellXform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "gi_probe_set_to_cell_xform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method gi_probe_set_to_cell_xform" } + } + } + + val hasChanged: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "has_changed".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_changed" } + } + } + + val hasFeature: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "has_feature".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_feature" } + } + } + + val hasOsFeature: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "has_os_feature".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_os_feature" } + } + } + + val immediateBegin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "immediate_begin".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method immediate_begin" } + } + } + + val immediateClear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "immediate_clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method immediate_clear" } + } + } + + val immediateColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "immediate_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method immediate_color" } + } + } + + val immediateCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "immediate_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method immediate_create" } + } + } + + val immediateEnd: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "immediate_end".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method immediate_end" } + } + } + + val immediateGetMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "immediate_get_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method immediate_get_material" } + } + } + + val immediateNormal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "immediate_normal".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method immediate_normal" } + } + } + + val immediateSetMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "immediate_set_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method immediate_set_material" } + } + } + + val immediateTangent: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "immediate_tangent".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method immediate_tangent" } + } + } + + val immediateUv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "immediate_uv".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method immediate_uv" } + } + } + + val immediateUv2: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "immediate_uv2".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method immediate_uv2" } + } + } + + val immediateVertex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "immediate_vertex".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method immediate_vertex" } + } + } + + val immediateVertex2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "immediate_vertex_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method immediate_vertex_2d" } + } + } + + val init: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "init".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method init" } + } + } + + val instanceAttachObjectInstanceId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_attach_object_instance_id".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method instance_attach_object_instance_id" } + } + } + + val instanceAttachSkeleton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_attach_skeleton".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method instance_attach_skeleton" } + } + } + + val instanceCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method instance_create" } + } + } + + val instanceCreate2: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_create2".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method instance_create2" } + } + } + + val instanceGeometrySetAsInstanceLod: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_geometry_set_as_instance_lod".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method instance_geometry_set_as_instance_lod" } + } + } + + val instanceGeometrySetCastShadowsSetting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_geometry_set_cast_shadows_setting".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method instance_geometry_set_cast_shadows_setting" } + } + } + + val instanceGeometrySetDrawRange: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_geometry_set_draw_range".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method instance_geometry_set_draw_range" } + } + } + + val instanceGeometrySetFlag: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_geometry_set_flag".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method instance_geometry_set_flag" } + } + } + + val instanceGeometrySetMaterialOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_geometry_set_material_override".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method instance_geometry_set_material_override" } + } + } + + val instanceSetBase: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_set_base".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method instance_set_base" } + } + } + + val instanceSetBlendShapeWeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_set_blend_shape_weight".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method instance_set_blend_shape_weight" } + } + } + + val instanceSetCustomAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_set_custom_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method instance_set_custom_aabb" } + } + } + + val instanceSetExterior: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_set_exterior".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method instance_set_exterior" } + } + } + + val instanceSetExtraVisibilityMargin: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_set_extra_visibility_margin".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method instance_set_extra_visibility_margin" } + } + } + + val instanceSetLayerMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_set_layer_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method instance_set_layer_mask" } + } + } + + val instanceSetScenario: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_set_scenario".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method instance_set_scenario" } + } + } + + val instanceSetSurfaceMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_set_surface_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method instance_set_surface_material" + } + } + } + + val instanceSetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method instance_set_transform" } + } + } + + val instanceSetUseLightmap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_set_use_lightmap".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method instance_set_use_lightmap" } + } + } + + val instanceSetVisible: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instance_set_visible".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method instance_set_visible" } + } + } + + val instancesCullAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instances_cull_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method instances_cull_aabb" } + } + } + + val instancesCullConvex: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instances_cull_convex".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method instances_cull_convex" } + } + } + + val instancesCullRay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "instances_cull_ray".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method instances_cull_ray" } + } + } + + val lightDirectionalSetBlendSplits: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "light_directional_set_blend_splits".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method light_directional_set_blend_splits" } + } + } + + val lightDirectionalSetShadowDepthRangeMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "light_directional_set_shadow_depth_range_mode".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method light_directional_set_shadow_depth_range_mode" } + } + } + + val lightDirectionalSetShadowMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "light_directional_set_shadow_mode".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method light_directional_set_shadow_mode" } + } + } + + val lightOmniSetShadowDetail: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "light_omni_set_shadow_detail".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method light_omni_set_shadow_detail" } + } + } + + val lightOmniSetShadowMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "light_omni_set_shadow_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method light_omni_set_shadow_mode" } + } + } + + val lightSetColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "light_set_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method light_set_color" } + } + } + + val lightSetCullMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "light_set_cull_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method light_set_cull_mask" } + } + } + + val lightSetNegative: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "light_set_negative".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method light_set_negative" } + } + } + + val lightSetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "light_set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method light_set_param" } + } + } + + val lightSetProjector: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "light_set_projector".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method light_set_projector" } + } + } + + val lightSetReverseCullFaceMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "light_set_reverse_cull_face_mode".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method light_set_reverse_cull_face_mode" } + } + } + + val lightSetShadow: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "light_set_shadow".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method light_set_shadow" } + } + } + + val lightSetShadowColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "light_set_shadow_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method light_set_shadow_color" } + } + } + + val lightSetUseGi: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "light_set_use_gi".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method light_set_use_gi" } + } + } + + val lightmapCaptureCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "lightmap_capture_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method lightmap_capture_create" } + } + } + + val lightmapCaptureGetBounds: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "lightmap_capture_get_bounds".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method lightmap_capture_get_bounds" } + } + } + + val lightmapCaptureGetEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "lightmap_capture_get_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method lightmap_capture_get_energy" } + } + } + + val lightmapCaptureGetOctree: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "lightmap_capture_get_octree".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method lightmap_capture_get_octree" } + } + } + + val lightmapCaptureGetOctreeCellSubdiv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "lightmap_capture_get_octree_cell_subdiv".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method lightmap_capture_get_octree_cell_subdiv" } + } + } + + val lightmapCaptureGetOctreeCellTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "lightmap_capture_get_octree_cell_transform".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method lightmap_capture_get_octree_cell_transform" } + } + } + + val lightmapCaptureSetBounds: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "lightmap_capture_set_bounds".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method lightmap_capture_set_bounds" } + } + } + + val lightmapCaptureSetEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "lightmap_capture_set_energy".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method lightmap_capture_set_energy" } + } + } + + val lightmapCaptureSetOctree: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "lightmap_capture_set_octree".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method lightmap_capture_set_octree" } + } + } + + val lightmapCaptureSetOctreeCellSubdiv: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "lightmap_capture_set_octree_cell_subdiv".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method lightmap_capture_set_octree_cell_subdiv" } + } + } + + val lightmapCaptureSetOctreeCellTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "lightmap_capture_set_octree_cell_transform".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method lightmap_capture_set_octree_cell_transform" } + } + } + + val makeSphereMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "make_sphere_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method make_sphere_mesh" } + } + } + + val materialCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "material_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method material_create" } + } + } + + val materialGetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "material_get_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method material_get_param" } + } + } + + val materialGetParamDefault: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "material_get_param_default".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method material_get_param_default" } + } + } + + val materialGetShader: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "material_get_shader".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method material_get_shader" } + } + } + + val materialSetLineWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "material_set_line_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method material_set_line_width" } + } + } + + val materialSetNextPass: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "material_set_next_pass".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method material_set_next_pass" } + } + } + + val materialSetParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "material_set_param".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method material_set_param" } + } + } + + val materialSetRenderPriority: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "material_set_render_priority".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method material_set_render_priority" } + } + } + + val materialSetShader: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "material_set_shader".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method material_set_shader" } + } + } + + val meshAddSurfaceFromArrays: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_add_surface_from_arrays".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_add_surface_from_arrays" } + } + } + + val meshClear: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_clear".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_clear" } + } + } + + val meshCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_create" } + } + } + + val meshGetBlendShapeCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_get_blend_shape_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_get_blend_shape_count" } + } + } + + val meshGetBlendShapeMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_get_blend_shape_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_get_blend_shape_mode" } + } + } + + val meshGetCustomAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_get_custom_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_get_custom_aabb" } + } + } + + val meshGetSurfaceCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_get_surface_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_get_surface_count" } + } + } + + val meshRemoveSurface: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_remove_surface".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_remove_surface" } + } + } + + val meshSetBlendShapeCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_set_blend_shape_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_set_blend_shape_count" } + } + } + + val meshSetBlendShapeMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_set_blend_shape_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_set_blend_shape_mode" } + } + } + + val meshSetCustomAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_set_custom_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_set_custom_aabb" } + } + } + + val meshSurfaceGetAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_surface_get_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_aabb" } + } + } + + val meshSurfaceGetArray: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_surface_get_array".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_array" } + } + } + + val meshSurfaceGetArrayIndexLen: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_surface_get_array_index_len".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method mesh_surface_get_array_index_len" } + } + } + + val meshSurfaceGetArrayLen: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_surface_get_array_len".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_array_len" } + } + } + + val meshSurfaceGetArrays: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_surface_get_arrays".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_arrays" } + } + } + + val meshSurfaceGetBlendShapeArrays: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_surface_get_blend_shape_arrays".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method mesh_surface_get_blend_shape_arrays" } + } + } + + val meshSurfaceGetFormat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_surface_get_format".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_format" } + } + } + + val meshSurfaceGetFormatOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_surface_get_format_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_format_offset" + } + } + } + + val meshSurfaceGetFormatStride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_surface_get_format_stride".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_format_stride" + } + } + } + + val meshSurfaceGetIndexArray: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_surface_get_index_array".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_index_array" } + } + } + + val meshSurfaceGetMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_surface_get_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_material" } + } + } + + val meshSurfaceGetPrimitiveType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_surface_get_primitive_type".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method mesh_surface_get_primitive_type" } + } + } + + val meshSurfaceGetSkeletonAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_surface_get_skeleton_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_skeleton_aabb" + } + } + } + + val meshSurfaceSetMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_surface_set_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_surface_set_material" } + } + } + + val meshSurfaceUpdateRegion: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "mesh_surface_update_region".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method mesh_surface_update_region" } + } + } + + val multimeshAllocate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "multimesh_allocate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method multimesh_allocate" } + } + } + + val multimeshCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "multimesh_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method multimesh_create" } + } + } + + val multimeshGetAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "multimesh_get_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method multimesh_get_aabb" } + } + } + + val multimeshGetInstanceCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "multimesh_get_instance_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method multimesh_get_instance_count" } + } + } + + val multimeshGetMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "multimesh_get_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method multimesh_get_mesh" } + } + } + + val multimeshGetVisibleInstances: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "multimesh_get_visible_instances".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method multimesh_get_visible_instances" } + } + } + + val multimeshInstanceGetColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "multimesh_instance_get_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method multimesh_instance_get_color" } + } + } + + val multimeshInstanceGetCustomData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "multimesh_instance_get_custom_data".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method multimesh_instance_get_custom_data" } + } + } + + val multimeshInstanceGetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "multimesh_instance_get_transform".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method multimesh_instance_get_transform" } + } + } + + val multimeshInstanceGetTransform2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "multimesh_instance_get_transform_2d".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method multimesh_instance_get_transform_2d" } + } + } + + val multimeshInstanceSetColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "multimesh_instance_set_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method multimesh_instance_set_color" } + } + } + + val multimeshInstanceSetCustomData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "multimesh_instance_set_custom_data".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method multimesh_instance_set_custom_data" } + } + } + + val multimeshInstanceSetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "multimesh_instance_set_transform".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method multimesh_instance_set_transform" } + } + } + + val multimeshInstanceSetTransform2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "multimesh_instance_set_transform_2d".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method multimesh_instance_set_transform_2d" } + } + } + + val multimeshSetAsBulkArray: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "multimesh_set_as_bulk_array".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method multimesh_set_as_bulk_array" } + } + } + + val multimeshSetMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "multimesh_set_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method multimesh_set_mesh" } + } + } + + val multimeshSetVisibleInstances: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "multimesh_set_visible_instances".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method multimesh_set_visible_instances" } + } + } + + val omniLightCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "omni_light_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method omni_light_create" } + } + } + + val particlesCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_create" } + } + } + + val particlesGetCurrentAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_get_current_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_get_current_aabb" } + } + } + + val particlesGetEmitting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_get_emitting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_get_emitting" } + } + } + + val particlesIsInactive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_is_inactive".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_is_inactive" } + } + } + + val particlesRequestProcess: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_request_process".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_request_process" } + } + } + + val particlesRestart: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_restart".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_restart" } + } + } + + val particlesSetAmount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_set_amount".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_set_amount" } + } + } + + val particlesSetCustomAabb: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_set_custom_aabb".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_set_custom_aabb" } + } + } + + val particlesSetDrawOrder: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_set_draw_order".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_set_draw_order" } + } + } + + val particlesSetDrawPassMesh: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_set_draw_pass_mesh".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_set_draw_pass_mesh" } + } + } + + val particlesSetDrawPasses: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_set_draw_passes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_set_draw_passes" } + } + } + + val particlesSetEmissionTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_set_emission_transform".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method particles_set_emission_transform" } + } + } + + val particlesSetEmitting: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_set_emitting".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_set_emitting" } + } + } + + val particlesSetExplosivenessRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_set_explosiveness_ratio".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method particles_set_explosiveness_ratio" } + } + } + + val particlesSetFixedFps: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_set_fixed_fps".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_set_fixed_fps" } + } + } + + val particlesSetFractionalDelta: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_set_fractional_delta".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_set_fractional_delta" + } + } + } + + val particlesSetLifetime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_set_lifetime".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_set_lifetime" } + } + } + + val particlesSetOneShot: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_set_one_shot".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_set_one_shot" } + } + } + + val particlesSetPreProcessTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_set_pre_process_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_set_pre_process_time" + } + } + } + + val particlesSetProcessMaterial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_set_process_material".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_set_process_material" + } + } + } + + val particlesSetRandomnessRatio: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_set_randomness_ratio".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_set_randomness_ratio" + } + } + } + + val particlesSetSpeedScale: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_set_speed_scale".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method particles_set_speed_scale" } + } + } + + val particlesSetUseLocalCoordinates: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "particles_set_use_local_coordinates".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method particles_set_use_local_coordinates" } + } + } + + val reflectionProbeCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "reflection_probe_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method reflection_probe_create" } + } + } + + val reflectionProbeSetAsInterior: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "reflection_probe_set_as_interior".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method reflection_probe_set_as_interior" } + } + } + + val reflectionProbeSetCullMask: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "reflection_probe_set_cull_mask".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method reflection_probe_set_cull_mask" + } + } + } + + val reflectionProbeSetEnableBoxProjection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "reflection_probe_set_enable_box_projection".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method reflection_probe_set_enable_box_projection" } + } + } + + val reflectionProbeSetEnableShadows: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "reflection_probe_set_enable_shadows".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method reflection_probe_set_enable_shadows" } + } + } + + val reflectionProbeSetExtents: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "reflection_probe_set_extents".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method reflection_probe_set_extents" } + } + } + + val reflectionProbeSetIntensity: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "reflection_probe_set_intensity".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method reflection_probe_set_intensity" + } + } + } + + val reflectionProbeSetInteriorAmbient: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "reflection_probe_set_interior_ambient".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method reflection_probe_set_interior_ambient" } + } + } + + val reflectionProbeSetInteriorAmbientEnergy: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "reflection_probe_set_interior_ambient_energy".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method reflection_probe_set_interior_ambient_energy" } + } + } + + val reflectionProbeSetInteriorAmbientProbeContribution: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "reflection_probe_set_interior_ambient_probe_contribution".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method reflection_probe_set_interior_ambient_probe_contribution" + } + } + } + + val reflectionProbeSetMaxDistance: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "reflection_probe_set_max_distance".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method reflection_probe_set_max_distance" } + } + } + + val reflectionProbeSetOriginOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "reflection_probe_set_origin_offset".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method reflection_probe_set_origin_offset" } + } + } + + val reflectionProbeSetUpdateMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "reflection_probe_set_update_mode".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method reflection_probe_set_update_mode" } + } + } + + val requestFrameDrawnCallback: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "request_frame_drawn_callback".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method request_frame_drawn_callback" } + } + } + + val scenarioCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "scenario_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method scenario_create" } + } + } + + val scenarioSetDebug: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "scenario_set_debug".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method scenario_set_debug" } + } + } + + val scenarioSetEnvironment: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "scenario_set_environment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method scenario_set_environment" } + } + } + + val scenarioSetFallbackEnvironment: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "scenario_set_fallback_environment".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method scenario_set_fallback_environment" } + } + } + + val scenarioSetReflectionAtlasSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "scenario_set_reflection_atlas_size".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method scenario_set_reflection_atlas_size" } + } + } + + val setBootImage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "set_boot_image".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_boot_image" } + } + } + + val setDebugGenerateWireframes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "set_debug_generate_wireframes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_debug_generate_wireframes" + } + } + } + + val setDefaultClearColor: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "set_default_clear_color".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_default_clear_color" } + } + } + + val shaderCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "shader_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shader_create" } + } + } + + val shaderGetCode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "shader_get_code".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shader_get_code" } + } + } + + val shaderGetDefaultTextureParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "shader_get_default_texture_param".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method shader_get_default_texture_param" } + } + } + + val shaderGetParamList: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "shader_get_param_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shader_get_param_list" } + } + } + + val shaderSetCode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "shader_set_code".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method shader_set_code" } + } + } + + val shaderSetDefaultTextureParam: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "shader_set_default_texture_param".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method shader_set_default_texture_param" } } - } - val canvasItemSetCustomRect: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_set_custom_rect".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_set_custom_rect" } - } - val canvasItemSetDistanceFieldMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_set_distance_field_mode".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method canvas_item_set_distance_field_mode" } - } - val canvasItemSetDrawBehindParent: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_set_draw_behind_parent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_set_draw_behind_parent" + } + + val skeletonAllocate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "skeleton_allocate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method skeleton_allocate" } } - } - val canvasItemSetDrawIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_set_draw_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_set_draw_index" } - } - val canvasItemSetLightMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_set_light_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_set_light_mask" } - } - val canvasItemSetMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_set_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_set_material" } - } - val canvasItemSetModulate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_set_modulate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_set_modulate" } - } - val canvasItemSetParent: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_set_parent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_set_parent" } - } - val canvasItemSetSelfModulate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_set_self_modulate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_set_self_modulate" } - } - val canvasItemSetSortChildrenByY: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_set_sort_children_by_y".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_set_sort_children_by_y" + } + + val skeletonBoneGetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "skeleton_bone_get_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method skeleton_bone_get_transform" } } - } - val canvasItemSetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_set_transform" } - } - val canvasItemSetUseParentMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_set_use_parent_material".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method canvas_item_set_use_parent_material" } - } - val canvasItemSetVisible: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_set_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_set_visible" } - } - val canvasItemSetZAsRelativeToParent: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_set_z_as_relative_to_parent".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method canvas_item_set_z_as_relative_to_parent" } - } - val canvasItemSetZIndex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_item_set_z_index".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_item_set_z_index" } - } - val canvasLightAttachToCanvas: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_attach_to_canvas".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_attach_to_canvas" } - } - val canvasLightCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_create" } - } - val canvasLightOccluderAttachToCanvas: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_occluder_attach_to_canvas".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method canvas_light_occluder_attach_to_canvas" } - } - val canvasLightOccluderCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_occluder_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_occluder_create" } - } - val canvasLightOccluderSetEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_occluder_set_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_occluder_set_enabled" + } + + val skeletonBoneGetTransform2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "skeleton_bone_get_transform_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method skeleton_bone_get_transform_2d" + } } - } - val canvasLightOccluderSetLightMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_occluder_set_light_mask".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method canvas_light_occluder_set_light_mask" } - } - val canvasLightOccluderSetPolygon: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_occluder_set_polygon".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_occluder_set_polygon" + } + + val skeletonBoneSetTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "skeleton_bone_set_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method skeleton_bone_set_transform" } } - } - val canvasLightOccluderSetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_occluder_set_transform".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method canvas_light_occluder_set_transform" } - } - val canvasLightSetColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_set_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_set_color" } - } - val canvasLightSetEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_set_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_set_enabled" } - } - val canvasLightSetEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_set_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_set_energy" } - } - val canvasLightSetHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_set_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_set_height" } - } - val canvasLightSetItemCullMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_set_item_cull_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_set_item_cull_mask" } - } - val canvasLightSetItemShadowCullMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_set_item_shadow_cull_mask".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method canvas_light_set_item_shadow_cull_mask" } - } - val canvasLightSetLayerRange: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_set_layer_range".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_set_layer_range" } - } - val canvasLightSetMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_set_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_set_mode" } - } - val canvasLightSetScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_set_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_set_scale" } - } - val canvasLightSetShadowBufferSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_set_shadow_buffer_size".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method canvas_light_set_shadow_buffer_size" } - } - val canvasLightSetShadowColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_set_shadow_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_set_shadow_color" } - } - val canvasLightSetShadowEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_set_shadow_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_set_shadow_enabled" } - } - val canvasLightSetShadowFilter: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_set_shadow_filter".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_set_shadow_filter" } - } - val canvasLightSetShadowGradientLength: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_set_shadow_gradient_length".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method canvas_light_set_shadow_gradient_length" } - } - val canvasLightSetShadowSmooth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_set_shadow_smooth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_set_shadow_smooth" } - } - val canvasLightSetTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_set_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_set_texture" } - } - val canvasLightSetTextureOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_set_texture_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_set_texture_offset" } - } - val canvasLightSetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_set_transform" } - } - val canvasLightSetZRange: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_light_set_z_range".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_light_set_z_range" } - } - val canvasOccluderPolygonCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_occluder_polygon_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_occluder_polygon_create" } - } - val canvasOccluderPolygonSetCullMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_occluder_polygon_set_cull_mode".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method canvas_occluder_polygon_set_cull_mode" } - } - val canvasOccluderPolygonSetShape: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_occluder_polygon_set_shape".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_occluder_polygon_set_shape" + } + + val skeletonBoneSetTransform2d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "skeleton_bone_set_transform_2d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method skeleton_bone_set_transform_2d" + } } - } - val canvasOccluderPolygonSetShapeAsLines: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_occluder_polygon_set_shape_as_lines".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method canvas_occluder_polygon_set_shape_as_lines" } - } - val canvasSetItemMirroring: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_set_item_mirroring".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_set_item_mirroring" } - } - val canvasSetModulate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "canvas_set_modulate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method canvas_set_modulate" } - } - val directionalLightCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "directional_light_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method directional_light_create" } - } - val draw: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "draw".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method draw" } - } - val environmentCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "environment_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method environment_create" } - } - val environmentSetAdjustment: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "environment_set_adjustment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method environment_set_adjustment" } - } - val environmentSetAmbientLight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "environment_set_ambient_light".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method environment_set_ambient_light" } - } - val environmentSetBackground: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "environment_set_background".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method environment_set_background" } - } - val environmentSetBgColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "environment_set_bg_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method environment_set_bg_color" } - } - val environmentSetBgEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "environment_set_bg_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method environment_set_bg_energy" } - } - val environmentSetCanvasMaxLayer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "environment_set_canvas_max_layer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method environment_set_canvas_max_layer" } - } - val environmentSetDofBlurFar: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "environment_set_dof_blur_far".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method environment_set_dof_blur_far" } - } - val environmentSetDofBlurNear: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "environment_set_dof_blur_near".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method environment_set_dof_blur_near" } - } - val environmentSetFog: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "environment_set_fog".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method environment_set_fog" } - } - val environmentSetFogDepth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "environment_set_fog_depth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method environment_set_fog_depth" } - } - val environmentSetFogHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "environment_set_fog_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method environment_set_fog_height" } - } - val environmentSetGlow: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "environment_set_glow".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method environment_set_glow" } - } - val environmentSetSky: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "environment_set_sky".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method environment_set_sky" } - } - val environmentSetSkyCustomFov: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "environment_set_sky_custom_fov".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method environment_set_sky_custom_fov" } - } - val environmentSetSkyOrientation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "environment_set_sky_orientation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method environment_set_sky_orientation" } - } - val environmentSetSsao: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "environment_set_ssao".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method environment_set_ssao" } - } - val environmentSetSsr: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "environment_set_ssr".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method environment_set_ssr" } - } - val environmentSetTonemap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "environment_set_tonemap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method environment_set_tonemap" } - } - val finish: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "finish".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method finish" } - } - val forceDraw: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "force_draw".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method force_draw" } - } - val forceSync: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "force_sync".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method force_sync" } - } - val freeRid: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "free_rid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method free_rid" } - } - val getRenderInfo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "get_render_info".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_render_info" } - } - val getTestCube: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "get_test_cube".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_test_cube" } - } - val getTestTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "get_test_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_test_texture" } - } - val getVideoAdapterName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "get_video_adapter_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_video_adapter_name" } - } - val getVideoAdapterVendor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "get_video_adapter_vendor".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_video_adapter_vendor" } - } - val getWhiteTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "get_white_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_white_texture" } - } - val giProbeCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_create" } - } - val giProbeGetBias: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_get_bias".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_get_bias" } - } - val giProbeGetBounds: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_get_bounds".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_get_bounds" } - } - val giProbeGetCellSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_get_cell_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_get_cell_size" } - } - val giProbeGetDynamicData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_get_dynamic_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_get_dynamic_data" } - } - val giProbeGetDynamicRange: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_get_dynamic_range".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_get_dynamic_range" } - } - val giProbeGetEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_get_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_get_energy" } - } - val giProbeGetNormalBias: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_get_normal_bias".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_get_normal_bias" } - } - val giProbeGetPropagation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_get_propagation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_get_propagation" } - } - val giProbeGetToCellXform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_get_to_cell_xform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_get_to_cell_xform" } - } - val giProbeIsCompressed: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_is_compressed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_is_compressed" } - } - val giProbeIsInterior: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_is_interior".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_is_interior" } - } - val giProbeSetBias: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_set_bias".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_set_bias" } - } - val giProbeSetBounds: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_set_bounds".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_set_bounds" } - } - val giProbeSetCellSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_set_cell_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_set_cell_size" } - } - val giProbeSetCompress: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_set_compress".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_set_compress" } - } - val giProbeSetDynamicData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_set_dynamic_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_set_dynamic_data" } - } - val giProbeSetDynamicRange: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_set_dynamic_range".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_set_dynamic_range" } - } - val giProbeSetEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_set_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_set_energy" } - } - val giProbeSetInterior: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_set_interior".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_set_interior" } - } - val giProbeSetNormalBias: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_set_normal_bias".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_set_normal_bias" } - } - val giProbeSetPropagation: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_set_propagation".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_set_propagation" } - } - val giProbeSetToCellXform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "gi_probe_set_to_cell_xform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method gi_probe_set_to_cell_xform" } - } - val hasChanged: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "has_changed".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_changed" } - } - val hasFeature: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "has_feature".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_feature" } - } - val hasOsFeature: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "has_os_feature".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_os_feature" } - } - val immediateBegin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "immediate_begin".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method immediate_begin" } - } - val immediateClear: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "immediate_clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method immediate_clear" } - } - val immediateColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "immediate_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method immediate_color" } - } - val immediateCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "immediate_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method immediate_create" } - } - val immediateEnd: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "immediate_end".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method immediate_end" } - } - val immediateGetMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "immediate_get_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method immediate_get_material" } - } - val immediateNormal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "immediate_normal".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method immediate_normal" } - } - val immediateSetMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "immediate_set_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method immediate_set_material" } - } - val immediateTangent: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "immediate_tangent".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method immediate_tangent" } - } - val immediateUv: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "immediate_uv".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method immediate_uv" } - } - val immediateUv2: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "immediate_uv2".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method immediate_uv2" } - } - val immediateVertex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "immediate_vertex".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method immediate_vertex" } - } - val immediateVertex2d: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "immediate_vertex_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method immediate_vertex_2d" } - } - val init: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "init".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method init" } - } - val instanceAttachObjectInstanceId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_attach_object_instance_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instance_attach_object_instance_id" + } + + val skeletonCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "skeleton_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method skeleton_create" } + } + } + + val skeletonGetBoneCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "skeleton_get_bone_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method skeleton_get_bone_count" } + } + } + + val skyCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "sky_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method sky_create" } + } + } + + val skySetTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "sky_set_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method sky_set_texture" } + } + } + + val spotLightCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "spot_light_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method spot_light_create" } + } + } + + val sync: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "sync".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method sync" } + } + } + + val textureAllocate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_allocate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method texture_allocate" } + } + } + + val textureBind: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_bind".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method texture_bind" } + } + } + + val textureCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method texture_create" } + } + } + + val textureCreateFromImage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_create_from_image".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method texture_create_from_image" } + } + } + + val textureDebugUsage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_debug_usage".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method texture_debug_usage" } + } + } + + val textureGetData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_get_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method texture_get_data" } + } + } + + val textureGetDepth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_get_depth".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method texture_get_depth" } + } + } + + val textureGetFlags: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_get_flags".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method texture_get_flags" } + } + } + + val textureGetFormat: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_get_format".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method texture_get_format" } + } + } + + val textureGetHeight: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_get_height".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method texture_get_height" } + } + } + + val textureGetPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_get_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method texture_get_path" } + } + } + + val textureGetTexid: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_get_texid".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method texture_get_texid" } + } + } + + val textureGetType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_get_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method texture_get_type" } + } + } + + val textureGetWidth: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_get_width".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method texture_get_width" } + } + } + + val textureSetData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_set_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method texture_set_data" } + } + } + + val textureSetDataPartial: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_set_data_partial".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method texture_set_data_partial" } + } + } + + val textureSetFlags: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_set_flags".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method texture_set_flags" } + } + } + + val textureSetPath: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_set_path".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method texture_set_path" } + } + } + + val textureSetShrinkAllX2OnSetData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_set_shrink_all_x2_on_set_data".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method texture_set_shrink_all_x2_on_set_data" } + } + } + + val textureSetSizeOverride: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "texture_set_size_override".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method texture_set_size_override" } + } + } + + val texturesKeepOriginal: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "textures_keep_original".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method textures_keep_original" } + } + } + + val viewportAttachCamera: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_attach_camera".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_attach_camera" } + } + } + + val viewportAttachCanvas: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_attach_canvas".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_attach_canvas" } + } + } + + val viewportAttachToScreen: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_attach_to_screen".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_attach_to_screen" } + } + } + + val viewportCreate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_create".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_create" } + } + } + + val viewportDetach: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_detach".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_detach" } + } + } + + val viewportGetRenderInfo: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_get_render_info".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_get_render_info" } + } + } + + val viewportGetTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_get_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_get_texture" } + } + } + + val viewportRemoveCanvas: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_remove_canvas".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_remove_canvas" } + } + } + + val viewportSetActive: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_active".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_set_active" } + } + } + + val viewportSetCanvasStacking: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_canvas_stacking".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_set_canvas_stacking" } + } + } + + val viewportSetCanvasTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_canvas_transform".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_set_canvas_transform" + } + } + } + + val viewportSetClearMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_clear_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_set_clear_mode" } + } + } + + val viewportSetDebugDraw: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_debug_draw".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_set_debug_draw" } + } + } + + val viewportSetDisable3d: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_disable_3d".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_set_disable_3d" } + } + } + + val viewportSetDisableEnvironment: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_disable_environment".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method viewport_set_disable_environment" } } - } - val instanceAttachSkeleton: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_attach_skeleton".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instance_attach_skeleton" } - } - val instanceCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instance_create" } - } - val instanceCreate2: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_create2".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instance_create2" } - } - val instanceGeometrySetAsInstanceLod: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_geometry_set_as_instance_lod".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method instance_geometry_set_as_instance_lod" } - } - val instanceGeometrySetCastShadowsSetting: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_geometry_set_cast_shadows_setting".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method instance_geometry_set_cast_shadows_setting" } - } - val instanceGeometrySetDrawRange: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_geometry_set_draw_range".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instance_geometry_set_draw_range" } - } - val instanceGeometrySetFlag: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_geometry_set_flag".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instance_geometry_set_flag" } - } - val instanceGeometrySetMaterialOverride: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_geometry_set_material_override".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method instance_geometry_set_material_override" } - } - val instanceSetBase: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_set_base".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instance_set_base" } - } - val instanceSetBlendShapeWeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_set_blend_shape_weight".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instance_set_blend_shape_weight" } - } - val instanceSetCustomAabb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_set_custom_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instance_set_custom_aabb" } - } - val instanceSetExterior: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_set_exterior".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instance_set_exterior" } - } - val instanceSetExtraVisibilityMargin: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_set_extra_visibility_margin".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method instance_set_extra_visibility_margin" } - } - val instanceSetLayerMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_set_layer_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instance_set_layer_mask" } - } - val instanceSetScenario: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_set_scenario".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instance_set_scenario" } - } - val instanceSetSurfaceMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_set_surface_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instance_set_surface_material" } - } - val instanceSetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instance_set_transform" } - } - val instanceSetUseLightmap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_set_use_lightmap".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instance_set_use_lightmap" } - } - val instanceSetVisible: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instance_set_visible".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instance_set_visible" } - } - val instancesCullAabb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instances_cull_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instances_cull_aabb" } - } - val instancesCullConvex: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instances_cull_convex".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instances_cull_convex" } - } - val instancesCullRay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "instances_cull_ray".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method instances_cull_ray" } - } - val lightDirectionalSetBlendSplits: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "light_directional_set_blend_splits".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method light_directional_set_blend_splits" + } + + val viewportSetGlobalCanvasTransform: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_global_canvas_transform".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method viewport_set_global_canvas_transform" } } - } - val lightDirectionalSetShadowDepthRangeMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "light_directional_set_shadow_depth_range_mode".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method light_directional_set_shadow_depth_range_mode" } - } - val lightDirectionalSetShadowMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "light_directional_set_shadow_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method light_directional_set_shadow_mode" + } + + val viewportSetHdr: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_hdr".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_set_hdr" } } - } - val lightOmniSetShadowDetail: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "light_omni_set_shadow_detail".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method light_omni_set_shadow_detail" } - } - val lightOmniSetShadowMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "light_omni_set_shadow_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method light_omni_set_shadow_mode" } - } - val lightSetColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "light_set_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method light_set_color" } - } - val lightSetCullMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "light_set_cull_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method light_set_cull_mask" } - } - val lightSetNegative: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "light_set_negative".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method light_set_negative" } - } - val lightSetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "light_set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method light_set_param" } - } - val lightSetProjector: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "light_set_projector".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method light_set_projector" } - } - val lightSetReverseCullFaceMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "light_set_reverse_cull_face_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method light_set_reverse_cull_face_mode" } - } - val lightSetShadow: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "light_set_shadow".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method light_set_shadow" } - } - val lightSetShadowColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "light_set_shadow_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method light_set_shadow_color" } - } - val lightSetUseGi: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "light_set_use_gi".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method light_set_use_gi" } - } - val lightmapCaptureCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "lightmap_capture_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method lightmap_capture_create" } - } - val lightmapCaptureGetBounds: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "lightmap_capture_get_bounds".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method lightmap_capture_get_bounds" } - } - val lightmapCaptureGetEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "lightmap_capture_get_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method lightmap_capture_get_energy" } - } - val lightmapCaptureGetOctree: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "lightmap_capture_get_octree".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method lightmap_capture_get_octree" } - } - val lightmapCaptureGetOctreeCellSubdiv: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "lightmap_capture_get_octree_cell_subdiv".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method lightmap_capture_get_octree_cell_subdiv" } - } - val lightmapCaptureGetOctreeCellTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "lightmap_capture_get_octree_cell_transform".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method lightmap_capture_get_octree_cell_transform" } - } - val lightmapCaptureSetBounds: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "lightmap_capture_set_bounds".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method lightmap_capture_set_bounds" } - } - val lightmapCaptureSetEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "lightmap_capture_set_energy".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method lightmap_capture_set_energy" } - } - val lightmapCaptureSetOctree: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "lightmap_capture_set_octree".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method lightmap_capture_set_octree" } - } - val lightmapCaptureSetOctreeCellSubdiv: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "lightmap_capture_set_octree_cell_subdiv".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method lightmap_capture_set_octree_cell_subdiv" } - } - val lightmapCaptureSetOctreeCellTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "lightmap_capture_set_octree_cell_transform".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method lightmap_capture_set_octree_cell_transform" } - } - val makeSphereMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "make_sphere_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method make_sphere_mesh" } - } - val materialCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "material_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method material_create" } - } - val materialGetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "material_get_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method material_get_param" } - } - val materialGetParamDefault: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "material_get_param_default".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method material_get_param_default" } - } - val materialGetShader: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "material_get_shader".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method material_get_shader" } - } - val materialSetLineWidth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "material_set_line_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method material_set_line_width" } - } - val materialSetNextPass: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "material_set_next_pass".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method material_set_next_pass" } - } - val materialSetParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "material_set_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method material_set_param" } - } - val materialSetRenderPriority: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "material_set_render_priority".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method material_set_render_priority" } - } - val materialSetShader: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "material_set_shader".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method material_set_shader" } - } - val meshAddSurfaceFromArrays: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_add_surface_from_arrays".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_add_surface_from_arrays" } - } - val meshClear: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_clear".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_clear" } - } - val meshCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_create" } - } - val meshGetBlendShapeCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_get_blend_shape_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_get_blend_shape_count" } - } - val meshGetBlendShapeMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_get_blend_shape_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_get_blend_shape_mode" } - } - val meshGetCustomAabb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_get_custom_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_get_custom_aabb" } - } - val meshGetSurfaceCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_get_surface_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_get_surface_count" } - } - val meshRemoveSurface: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_remove_surface".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_remove_surface" } - } - val meshSetBlendShapeCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_set_blend_shape_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_set_blend_shape_count" } - } - val meshSetBlendShapeMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_set_blend_shape_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_set_blend_shape_mode" } - } - val meshSetCustomAabb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_set_custom_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_set_custom_aabb" } - } - val meshSurfaceGetAabb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_surface_get_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_aabb" } - } - val meshSurfaceGetArray: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_surface_get_array".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_array" } - } - val meshSurfaceGetArrayIndexLen: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_surface_get_array_index_len".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_array_index_len" } - } - val meshSurfaceGetArrayLen: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_surface_get_array_len".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_array_len" } - } - val meshSurfaceGetArrays: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_surface_get_arrays".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_arrays" } - } - val meshSurfaceGetBlendShapeArrays: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_surface_get_blend_shape_arrays".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method mesh_surface_get_blend_shape_arrays" } - } - val meshSurfaceGetFormat: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_surface_get_format".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_format" } - } - val meshSurfaceGetFormatOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_surface_get_format_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_format_offset" } - } - val meshSurfaceGetFormatStride: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_surface_get_format_stride".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_format_stride" } - } - val meshSurfaceGetIndexArray: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_surface_get_index_array".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_index_array" } - } - val meshSurfaceGetMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_surface_get_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_material" } - } - val meshSurfaceGetPrimitiveType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_surface_get_primitive_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_primitive_type" } - } - val meshSurfaceGetSkeletonAabb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_surface_get_skeleton_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_surface_get_skeleton_aabb" } - } - val meshSurfaceSetMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_surface_set_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_surface_set_material" } - } - val meshSurfaceUpdateRegion: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "mesh_surface_update_region".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method mesh_surface_update_region" } - } - val multimeshAllocate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "multimesh_allocate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method multimesh_allocate" } - } - val multimeshCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "multimesh_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method multimesh_create" } - } - val multimeshGetAabb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "multimesh_get_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method multimesh_get_aabb" } - } - val multimeshGetInstanceCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "multimesh_get_instance_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method multimesh_get_instance_count" } - } - val multimeshGetMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "multimesh_get_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method multimesh_get_mesh" } - } - val multimeshGetVisibleInstances: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "multimesh_get_visible_instances".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method multimesh_get_visible_instances" } - } - val multimeshInstanceGetColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "multimesh_instance_get_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method multimesh_instance_get_color" } - } - val multimeshInstanceGetCustomData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "multimesh_instance_get_custom_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method multimesh_instance_get_custom_data" + } + + val viewportSetHideCanvas: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_hide_canvas".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_set_hide_canvas" } } - } - val multimeshInstanceGetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "multimesh_instance_get_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method multimesh_instance_get_transform" } - } - val multimeshInstanceGetTransform2d: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "multimesh_instance_get_transform_2d".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method multimesh_instance_get_transform_2d" } - } - val multimeshInstanceSetColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "multimesh_instance_set_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method multimesh_instance_set_color" } - } - val multimeshInstanceSetCustomData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "multimesh_instance_set_custom_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method multimesh_instance_set_custom_data" + } + + val viewportSetHideScenario: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_hide_scenario".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_set_hide_scenario" } } - } - val multimeshInstanceSetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "multimesh_instance_set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method multimesh_instance_set_transform" } - } - val multimeshInstanceSetTransform2d: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "multimesh_instance_set_transform_2d".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method multimesh_instance_set_transform_2d" } - } - val multimeshSetAsBulkArray: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "multimesh_set_as_bulk_array".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method multimesh_set_as_bulk_array" } - } - val multimeshSetMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "multimesh_set_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method multimesh_set_mesh" } - } - val multimeshSetVisibleInstances: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "multimesh_set_visible_instances".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method multimesh_set_visible_instances" } - } - val omniLightCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "omni_light_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method omni_light_create" } - } - val particlesCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_create" } - } - val particlesGetCurrentAabb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_get_current_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_get_current_aabb" } - } - val particlesGetEmitting: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_get_emitting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_get_emitting" } - } - val particlesIsInactive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_is_inactive".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_is_inactive" } - } - val particlesRequestProcess: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_request_process".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_request_process" } - } - val particlesRestart: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_restart".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_restart" } - } - val particlesSetAmount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_set_amount".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_set_amount" } - } - val particlesSetCustomAabb: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_set_custom_aabb".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_set_custom_aabb" } - } - val particlesSetDrawOrder: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_set_draw_order".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_set_draw_order" } - } - val particlesSetDrawPassMesh: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_set_draw_pass_mesh".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_set_draw_pass_mesh" } - } - val particlesSetDrawPasses: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_set_draw_passes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_set_draw_passes" } - } - val particlesSetEmissionTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_set_emission_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_set_emission_transform" } - } - val particlesSetEmitting: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_set_emitting".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_set_emitting" } - } - val particlesSetExplosivenessRatio: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_set_explosiveness_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_set_explosiveness_ratio" + } + + val viewportSetMsaa: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_msaa".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_set_msaa" } } - } - val particlesSetFixedFps: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_set_fixed_fps".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_set_fixed_fps" } - } - val particlesSetFractionalDelta: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_set_fractional_delta".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_set_fractional_delta" } - } - val particlesSetLifetime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_set_lifetime".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_set_lifetime" } - } - val particlesSetOneShot: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_set_one_shot".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_set_one_shot" } - } - val particlesSetPreProcessTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_set_pre_process_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_set_pre_process_time" } - } - val particlesSetProcessMaterial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_set_process_material".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_set_process_material" } - } - val particlesSetRandomnessRatio: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_set_randomness_ratio".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_set_randomness_ratio" } - } - val particlesSetSpeedScale: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_set_speed_scale".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method particles_set_speed_scale" } - } - val particlesSetUseLocalCoordinates: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "particles_set_use_local_coordinates".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method particles_set_use_local_coordinates" } - } - val reflectionProbeCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "reflection_probe_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method reflection_probe_create" } - } - val reflectionProbeSetAsInterior: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "reflection_probe_set_as_interior".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method reflection_probe_set_as_interior" } - } - val reflectionProbeSetCullMask: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "reflection_probe_set_cull_mask".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method reflection_probe_set_cull_mask" } - } - val reflectionProbeSetEnableBoxProjection: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "reflection_probe_set_enable_box_projection".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method reflection_probe_set_enable_box_projection" } - } - val reflectionProbeSetEnableShadows: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "reflection_probe_set_enable_shadows".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method reflection_probe_set_enable_shadows" } - } - val reflectionProbeSetExtents: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "reflection_probe_set_extents".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method reflection_probe_set_extents" } - } - val reflectionProbeSetIntensity: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "reflection_probe_set_intensity".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method reflection_probe_set_intensity" } - } - val reflectionProbeSetInteriorAmbient: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "reflection_probe_set_interior_ambient".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method reflection_probe_set_interior_ambient" } - } - val reflectionProbeSetInteriorAmbientEnergy: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "reflection_probe_set_interior_ambient_energy".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method reflection_probe_set_interior_ambient_energy" } - } - val reflectionProbeSetInteriorAmbientProbeContribution: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "reflection_probe_set_interior_ambient_probe_contribution".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method reflection_probe_set_interior_ambient_probe_contribution" + } + + val viewportSetParentViewport: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_parent_viewport".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_set_parent_viewport" } } - } - val reflectionProbeSetMaxDistance: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "reflection_probe_set_max_distance".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method reflection_probe_set_max_distance" + } + + val viewportSetRenderDirectToScreen: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_render_direct_to_screen".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method viewport_set_render_direct_to_screen" } } - } - val reflectionProbeSetOriginOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "reflection_probe_set_origin_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method reflection_probe_set_origin_offset" + } + + val viewportSetScenario: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_scenario".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_set_scenario" } } - } - val reflectionProbeSetUpdateMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "reflection_probe_set_update_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method reflection_probe_set_update_mode" } - } - val requestFrameDrawnCallback: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "request_frame_drawn_callback".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method request_frame_drawn_callback" } - } - val scenarioCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "scenario_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method scenario_create" } - } - val scenarioSetDebug: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "scenario_set_debug".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method scenario_set_debug" } - } - val scenarioSetEnvironment: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "scenario_set_environment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method scenario_set_environment" } - } - val scenarioSetFallbackEnvironment: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "scenario_set_fallback_environment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method scenario_set_fallback_environment" + } + + val viewportSetShadowAtlasQuadrantSubdivision: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_shadow_atlas_quadrant_subdivision".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method viewport_set_shadow_atlas_quadrant_subdivision" } } - } - val scenarioSetReflectionAtlasSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "scenario_set_reflection_atlas_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method scenario_set_reflection_atlas_size" + } + + val viewportSetShadowAtlasSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_shadow_atlas_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_set_shadow_atlas_size" + } } - } - val setBootImage: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "set_boot_image".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_boot_image" } - } - val setDebugGenerateWireframes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "set_debug_generate_wireframes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_debug_generate_wireframes" } - } - val setDefaultClearColor: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "set_default_clear_color".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_default_clear_color" } - } - val shaderCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "shader_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shader_create" } - } - val shaderGetCode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "shader_get_code".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shader_get_code" } - } - val shaderGetDefaultTextureParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "shader_get_default_texture_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shader_get_default_texture_param" } - } - val shaderGetParamList: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "shader_get_param_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shader_get_param_list" } - } - val shaderSetCode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "shader_set_code".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shader_set_code" } - } - val shaderSetDefaultTextureParam: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "shader_set_default_texture_param".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method shader_set_default_texture_param" } - } - val skeletonAllocate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "skeleton_allocate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method skeleton_allocate" } - } - val skeletonBoneGetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "skeleton_bone_get_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method skeleton_bone_get_transform" } - } - val skeletonBoneGetTransform2d: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "skeleton_bone_get_transform_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method skeleton_bone_get_transform_2d" } - } - val skeletonBoneSetTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "skeleton_bone_set_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method skeleton_bone_set_transform" } - } - val skeletonBoneSetTransform2d: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "skeleton_bone_set_transform_2d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method skeleton_bone_set_transform_2d" } - } - val skeletonCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "skeleton_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method skeleton_create" } - } - val skeletonGetBoneCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "skeleton_get_bone_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method skeleton_get_bone_count" } - } - val skyCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "sky_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method sky_create" } - } - val skySetTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "sky_set_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method sky_set_texture" } - } - val spotLightCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "spot_light_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method spot_light_create" } - } - val sync: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "sync".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method sync" } - } - val textureAllocate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_allocate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method texture_allocate" } - } - val textureBind: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_bind".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method texture_bind" } - } - val textureCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method texture_create" } - } - val textureCreateFromImage: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_create_from_image".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method texture_create_from_image" } - } - val textureDebugUsage: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_debug_usage".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method texture_debug_usage" } - } - val textureGetData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_get_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method texture_get_data" } - } - val textureGetDepth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_get_depth".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method texture_get_depth" } - } - val textureGetFlags: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_get_flags".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method texture_get_flags" } - } - val textureGetFormat: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_get_format".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method texture_get_format" } - } - val textureGetHeight: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_get_height".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method texture_get_height" } - } - val textureGetPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_get_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method texture_get_path" } - } - val textureGetTexid: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_get_texid".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method texture_get_texid" } - } - val textureGetType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_get_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method texture_get_type" } - } - val textureGetWidth: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_get_width".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method texture_get_width" } - } - val textureSetData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_set_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method texture_set_data" } - } - val textureSetDataPartial: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_set_data_partial".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method texture_set_data_partial" } - } - val textureSetFlags: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_set_flags".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method texture_set_flags" } - } - val textureSetPath: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_set_path".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method texture_set_path" } - } - val textureSetShrinkAllX2OnSetData: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_set_shrink_all_x2_on_set_data".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method texture_set_shrink_all_x2_on_set_data" } - } - val textureSetSizeOverride: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "texture_set_size_override".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method texture_set_size_override" } - } - val texturesKeepOriginal: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "textures_keep_original".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method textures_keep_original" } - } - val viewportAttachCamera: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_attach_camera".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_attach_camera" } - } - val viewportAttachCanvas: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_attach_canvas".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_attach_canvas" } - } - val viewportAttachToScreen: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_attach_to_screen".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_attach_to_screen" } - } - val viewportCreate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_create".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_create" } - } - val viewportDetach: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_detach".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_detach" } - } - val viewportGetRenderInfo: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_get_render_info".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_get_render_info" } - } - val viewportGetTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_get_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_get_texture" } - } - val viewportRemoveCanvas: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_remove_canvas".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_remove_canvas" } - } - val viewportSetActive: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_active".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_set_active" } - } - val viewportSetCanvasStacking: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_canvas_stacking".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_set_canvas_stacking" } - } - val viewportSetCanvasTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_canvas_transform".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_set_canvas_transform" } - } - val viewportSetClearMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_clear_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_set_clear_mode" } - } - val viewportSetDebugDraw: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_debug_draw".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_set_debug_draw" } - } - val viewportSetDisable3d: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_disable_3d".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_set_disable_3d" } - } - val viewportSetDisableEnvironment: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_disable_environment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_set_disable_environment" } - } - val viewportSetGlobalCanvasTransform: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_global_canvas_transform".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method viewport_set_global_canvas_transform" } - } - val viewportSetHdr: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_hdr".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_set_hdr" } - } - val viewportSetHideCanvas: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_hide_canvas".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_set_hide_canvas" } - } - val viewportSetHideScenario: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_hide_scenario".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_set_hide_scenario" } - } - val viewportSetMsaa: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_msaa".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_set_msaa" } - } - val viewportSetParentViewport: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_parent_viewport".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_set_parent_viewport" } - } - val viewportSetRenderDirectToScreen: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_render_direct_to_screen".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method viewport_set_render_direct_to_screen" } - } - val viewportSetScenario: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_scenario".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_set_scenario" } - } - val viewportSetShadowAtlasQuadrantSubdivision: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_shadow_atlas_quadrant_subdivision".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method viewport_set_shadow_atlas_quadrant_subdivision" } - } - val viewportSetShadowAtlasSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_shadow_atlas_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_set_shadow_atlas_size" } - } - val viewportSetSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_set_size" } - } - val viewportSetTransparentBackground: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_transparent_background".cstr.ptr) - requireNotNull(ptr) { - "No method_bind found for method viewport_set_transparent_background" } - } - val viewportSetUpdateMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_update_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_set_update_mode" } - } - val viewportSetUsage: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_usage".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_set_usage" } - } - val viewportSetUseArvr: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_use_arvr".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_set_use_arvr" } - } - val viewportSetVflip: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, - "viewport_set_vflip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method viewport_set_vflip" } - }} + } + + val viewportSetSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_set_size" } + } + } + + val viewportSetTransparentBackground: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_transparent_background".cstr.ptr) + requireNotNull(ptr) { + "No method_bind found for method viewport_set_transparent_background" } + } + } + + val viewportSetUpdateMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_update_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_set_update_mode" } + } + } + + val viewportSetUsage: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_usage".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_set_usage" } + } + } + + val viewportSetUseArvr: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_use_arvr".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_set_use_arvr" } + } + } + + val viewportSetVflip: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualServer".cstr.ptr, + "viewport_set_vflip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method viewport_set_vflip" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShader.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShader.kt index eb4f6272..dea3ecfa 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShader.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShader.kt @@ -341,117 +341,149 @@ open class VisualShader( * Container for method_bind pointers for VisualShader */ private object __method_bind { - val addNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, - "add_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_node" } - } - val canConnectNodes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, - "can_connect_nodes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method can_connect_nodes" } - } - val connectNodes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, - "connect_nodes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method connect_nodes" } - } - val connectNodesForced: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, - "connect_nodes_forced".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method connect_nodes_forced" } - } - val disconnectNodes: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, - "disconnect_nodes".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method disconnect_nodes" } - } - val getGraphOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, - "get_graph_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_graph_offset" } - } - val getNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, - "get_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node" } - } - val getNodeConnections: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, - "get_node_connections".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_connections" } - } - val getNodeList: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, - "get_node_list".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_list" } - } - val getNodePosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, - "get_node_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_position" } - } - val getValidNodeId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, - "get_valid_node_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_valid_node_id" } - } - val isNodeConnection: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, - "is_node_connection".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_node_connection" } - } - val removeNode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, - "remove_node".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_node" } - } - val setGraphOffset: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, - "set_graph_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_graph_offset" } - } - val setMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, - "set_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_mode" } - } - val setNodePosition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, - "set_node_position".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_node_position" } - }} + val addNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, + "add_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_node" } + } + } + + val canConnectNodes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, + "can_connect_nodes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method can_connect_nodes" } + } + } + + val connectNodes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, + "connect_nodes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method connect_nodes" } + } + } + + val connectNodesForced: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, + "connect_nodes_forced".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method connect_nodes_forced" } + } + } + + val disconnectNodes: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, + "disconnect_nodes".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method disconnect_nodes" } + } + } + + val getGraphOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, + "get_graph_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_graph_offset" } + } + } + + val getNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, + "get_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node" } + } + } + + val getNodeConnections: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, + "get_node_connections".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_connections" } + } + } + + val getNodeList: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, + "get_node_list".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_list" } + } + } + + val getNodePosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, + "get_node_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_position" } + } + } + + val getValidNodeId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, + "get_valid_node_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_valid_node_id" } + } + } + + val isNodeConnection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, + "is_node_connection".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_node_connection" } + } + } + + val removeNode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, + "remove_node".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_node" } + } + } + + val setGraphOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, + "set_graph_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_graph_offset" } + } + } + + val setMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, + "set_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_mode" } + } + } + + val setNodePosition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShader".cstr.ptr, + "set_node_position".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_node_position" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNode.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNode.kt index 5cf212ff..c994680d 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNode.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNode.kt @@ -146,47 +146,59 @@ open class VisualShaderNode( * Container for method_bind pointers for VisualShaderNode */ private object __method_bind { - val getDefaultInputValues: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNode".cstr.ptr, - "get_default_input_values".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_default_input_values" } - } - val getInputPortDefaultValue: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNode".cstr.ptr, - "get_input_port_default_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_input_port_default_value" } - } - val getOutputPortForPreview: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNode".cstr.ptr, - "get_output_port_for_preview".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_output_port_for_preview" } - } - val setDefaultInputValues: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNode".cstr.ptr, - "set_default_input_values".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_default_input_values" } - } - val setInputPortDefaultValue: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNode".cstr.ptr, - "set_input_port_default_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_input_port_default_value" } - } - val setOutputPortForPreview: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNode".cstr.ptr, - "set_output_port_for_preview".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_output_port_for_preview" } - }} + val getDefaultInputValues: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNode".cstr.ptr, + "get_default_input_values".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_default_input_values" } + } + } + + val getInputPortDefaultValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNode".cstr.ptr, + "get_input_port_default_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_input_port_default_value" } + } + } + + val getOutputPortForPreview: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNode".cstr.ptr, + "get_output_port_for_preview".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_output_port_for_preview" } + } + } + + val setDefaultInputValues: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNode".cstr.ptr, + "set_default_input_values".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_default_input_values" } + } + } + + val setInputPortDefaultValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNode".cstr.ptr, + "set_input_port_default_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_input_port_default_value" } + } + } + + val setOutputPortForPreview: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNode".cstr.ptr, + "set_output_port_for_preview".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_output_port_for_preview" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeBooleanConstant.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeBooleanConstant.kt index 34355683..66773cf6 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeBooleanConstant.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeBooleanConstant.kt @@ -74,19 +74,23 @@ open class VisualShaderNodeBooleanConstant( * Container for method_bind pointers for VisualShaderNodeBooleanConstant */ private object __method_bind { - val getConstant: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeBooleanConstant".cstr.ptr, - "get_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_constant" } - } - val setConstant: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeBooleanConstant".cstr.ptr, - "set_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_constant" } - }} + val getConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeBooleanConstant".cstr.ptr, + "get_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_constant" } + } + } + + val setConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeBooleanConstant".cstr.ptr, + "set_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_constant" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeColorConstant.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeColorConstant.kt index 7d2ab295..aeb92e54 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeColorConstant.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeColorConstant.kt @@ -85,19 +85,23 @@ open class VisualShaderNodeColorConstant( * Container for method_bind pointers for VisualShaderNodeColorConstant */ private object __method_bind { - val getConstant: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeColorConstant".cstr.ptr, - "get_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_constant" } - } - val setConstant: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeColorConstant".cstr.ptr, - "set_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_constant" } - }} + val getConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeColorConstant".cstr.ptr, + "get_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_constant" } + } + } + + val setConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeColorConstant".cstr.ptr, + "set_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_constant" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeColorFunc.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeColorFunc.kt index 4a5ee264..6235cdcd 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeColorFunc.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeColorFunc.kt @@ -93,19 +93,23 @@ open class VisualShaderNodeColorFunc( * Container for method_bind pointers for VisualShaderNodeColorFunc */ private object __method_bind { - val getFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeColorFunc".cstr.ptr, - "get_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_function" } - } - val setFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeColorFunc".cstr.ptr, - "set_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_function" } - }} + val getFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeColorFunc".cstr.ptr, + "get_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_function" } + } + } + + val setFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeColorFunc".cstr.ptr, + "set_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_function" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeColorOp.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeColorOp.kt index 8eeef675..77cae21b 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeColorOp.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeColorOp.kt @@ -107,19 +107,23 @@ open class VisualShaderNodeColorOp( * Container for method_bind pointers for VisualShaderNodeColorOp */ private object __method_bind { - val getOperator: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeColorOp".cstr.ptr, - "get_operator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_operator" } - } - val setOperator: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeColorOp".cstr.ptr, - "set_operator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_operator" } - }} + val getOperator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeColorOp".cstr.ptr, + "get_operator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_operator" } + } + } + + val setOperator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeColorOp".cstr.ptr, + "set_operator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_operator" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeCompare.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeCompare.kt index 62acbb81..fcf28dae 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeCompare.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeCompare.kt @@ -193,47 +193,59 @@ open class VisualShaderNodeCompare( * Container for method_bind pointers for VisualShaderNodeCompare */ private object __method_bind { - val getComparisonType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCompare".cstr.ptr, - "get_comparison_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_comparison_type" } - } - val getCondition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCompare".cstr.ptr, - "get_condition".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_condition" } - } - val getFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCompare".cstr.ptr, - "get_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_function" } - } - val setComparisonType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCompare".cstr.ptr, - "set_comparison_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_comparison_type" } - } - val setCondition: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCompare".cstr.ptr, - "set_condition".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_condition" } - } - val setFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCompare".cstr.ptr, - "set_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_function" } - }} + val getComparisonType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCompare".cstr.ptr, + "get_comparison_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_comparison_type" } + } + } + + val getCondition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCompare".cstr.ptr, + "get_condition".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_condition" } + } + } + + val getFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCompare".cstr.ptr, + "get_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_function" } + } + } + + val setComparisonType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCompare".cstr.ptr, + "set_comparison_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_comparison_type" } + } + } + + val setCondition: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCompare".cstr.ptr, + "set_condition".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_condition" } + } + } + + val setFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCompare".cstr.ptr, + "set_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_function" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeCubeMap.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeCubeMap.kt index 77bdc6a1..384ff706 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeCubeMap.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeCubeMap.kt @@ -166,47 +166,59 @@ open class VisualShaderNodeCubeMap( * Container for method_bind pointers for VisualShaderNodeCubeMap */ private object __method_bind { - val getCubeMap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCubeMap".cstr.ptr, - "get_cube_map".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_cube_map" } - } - val getSource: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCubeMap".cstr.ptr, - "get_source".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_source" } - } - val getTextureType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCubeMap".cstr.ptr, - "get_texture_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture_type" } - } - val setCubeMap: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCubeMap".cstr.ptr, - "set_cube_map".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_cube_map" } - } - val setSource: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCubeMap".cstr.ptr, - "set_source".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_source" } - } - val setTextureType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCubeMap".cstr.ptr, - "set_texture_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture_type" } - }} + val getCubeMap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCubeMap".cstr.ptr, + "get_cube_map".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_cube_map" } + } + } + + val getSource: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCubeMap".cstr.ptr, + "get_source".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_source" } + } + } + + val getTextureType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCubeMap".cstr.ptr, + "get_texture_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture_type" } + } + } + + val setCubeMap: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCubeMap".cstr.ptr, + "set_cube_map".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_cube_map" } + } + } + + val setSource: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCubeMap".cstr.ptr, + "set_source".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_source" } + } + } + + val setTextureType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeCubeMap".cstr.ptr, + "set_texture_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture_type" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeExpression.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeExpression.kt index 20c07f68..4cfee44a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeExpression.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeExpression.kt @@ -74,19 +74,23 @@ open class VisualShaderNodeExpression( * Container for method_bind pointers for VisualShaderNodeExpression */ private object __method_bind { - val getExpression: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeExpression".cstr.ptr, - "get_expression".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_expression" } - } - val setExpression: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeExpression".cstr.ptr, - "set_expression".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_expression" } - }} + val getExpression: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeExpression".cstr.ptr, + "get_expression".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_expression" } + } + } + + val setExpression: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeExpression".cstr.ptr, + "set_expression".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_expression" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeGroupBase.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeGroupBase.kt index a8fbb199..e4d72691 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeGroupBase.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeGroupBase.kt @@ -291,166 +291,212 @@ open class VisualShaderNodeGroupBase( * Container for method_bind pointers for VisualShaderNodeGroupBase */ private object __method_bind { - val addInputPort: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "add_input_port".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_input_port" } - } - val addOutputPort: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "add_output_port".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_output_port" } - } - val clearInputPorts: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "clear_input_ports".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_input_ports" } - } - val clearOutputPorts: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "clear_output_ports".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method clear_output_ports" } - } - val getFreeInputPortId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "get_free_input_port_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_free_input_port_id" } - } - val getFreeOutputPortId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "get_free_output_port_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_free_output_port_id" } - } - val getInputPortCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "get_input_port_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_input_port_count" } - } - val getInputs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "get_inputs".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_inputs" } - } - val getOutputPortCount: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "get_output_port_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_output_port_count" } - } - val getOutputs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "get_outputs".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_outputs" } - } - val getSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "get_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_size" } - } - val hasInputPort: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "has_input_port".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_input_port" } - } - val hasOutputPort: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "has_output_port".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_output_port" } - } - val isValidPortName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "is_valid_port_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_valid_port_name" } - } - val removeInputPort: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "remove_input_port".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_input_port" } - } - val removeOutputPort: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "remove_output_port".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_output_port" } - } - val setInputPortName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "set_input_port_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_input_port_name" } - } - val setInputPortType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "set_input_port_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_input_port_type" } - } - val setInputs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "set_inputs".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_inputs" } - } - val setOutputPortName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "set_output_port_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_output_port_name" } - } - val setOutputPortType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "set_output_port_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_output_port_type" } - } - val setOutputs: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "set_outputs".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_outputs" } - } - val setSize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, - "set_size".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_size" } - }} + val addInputPort: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "add_input_port".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_input_port" } + } + } + + val addOutputPort: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "add_output_port".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_output_port" } + } + } + + val clearInputPorts: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "clear_input_ports".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_input_ports" } + } + } + + val clearOutputPorts: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "clear_output_ports".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method clear_output_ports" } + } + } + + val getFreeInputPortId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "get_free_input_port_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_free_input_port_id" } + } + } + + val getFreeOutputPortId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "get_free_output_port_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_free_output_port_id" } + } + } + + val getInputPortCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "get_input_port_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_input_port_count" } + } + } + + val getInputs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "get_inputs".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_inputs" } + } + } + + val getOutputPortCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "get_output_port_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_output_port_count" } + } + } + + val getOutputs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "get_outputs".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_outputs" } + } + } + + val getSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "get_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_size" } + } + } + + val hasInputPort: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "has_input_port".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_input_port" } + } + } + + val hasOutputPort: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "has_output_port".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_output_port" } + } + } + + val isValidPortName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "is_valid_port_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_valid_port_name" } + } + } + + val removeInputPort: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "remove_input_port".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_input_port" } + } + } + + val removeOutputPort: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "remove_output_port".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_output_port" } + } + } + + val setInputPortName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "set_input_port_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_input_port_name" } + } + } + + val setInputPortType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "set_input_port_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_input_port_type" } + } + } + + val setInputs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "set_inputs".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_inputs" } + } + } + + val setOutputPortName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "set_output_port_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_output_port_name" } + } + } + + val setOutputPortType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "set_output_port_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_output_port_type" } + } + } + + val setOutputs: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "set_outputs".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_outputs" } + } + } + + val setSize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeGroupBase".cstr.ptr, + "set_size".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_size" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeInput.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeInput.kt index af3c3164..7dfe9070 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeInput.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeInput.kt @@ -90,26 +90,32 @@ open class VisualShaderNodeInput( * Container for method_bind pointers for VisualShaderNodeInput */ private object __method_bind { - val getInputName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeInput".cstr.ptr, - "get_input_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_input_name" } - } - val getInputRealName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeInput".cstr.ptr, - "get_input_real_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_input_real_name" } - } - val setInputName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeInput".cstr.ptr, - "set_input_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_input_name" } - }} + val getInputName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeInput".cstr.ptr, + "get_input_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_input_name" } + } + } + + val getInputRealName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeInput".cstr.ptr, + "get_input_real_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_input_real_name" } + } + } + + val setInputName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeInput".cstr.ptr, + "set_input_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_input_name" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeIs.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeIs.kt index 89dfb56a..5b900c4e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeIs.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeIs.kt @@ -93,19 +93,23 @@ open class VisualShaderNodeIs( * Container for method_bind pointers for VisualShaderNodeIs */ private object __method_bind { - val getFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeIs".cstr.ptr, - "get_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_function" } - } - val setFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeIs".cstr.ptr, - "set_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_function" } - }} + val getFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeIs".cstr.ptr, + "get_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_function" } + } + } + + val setFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeIs".cstr.ptr, + "set_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_function" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeScalarConstant.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeScalarConstant.kt index ed6827dc..035f3ddc 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeScalarConstant.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeScalarConstant.kt @@ -74,19 +74,23 @@ open class VisualShaderNodeScalarConstant( * Container for method_bind pointers for VisualShaderNodeScalarConstant */ private object __method_bind { - val getConstant: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeScalarConstant".cstr.ptr, - "get_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_constant" } - } - val setConstant: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeScalarConstant".cstr.ptr, - "set_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_constant" } - }} + val getConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeScalarConstant".cstr.ptr, + "get_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_constant" } + } + } + + val setConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeScalarConstant".cstr.ptr, + "set_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_constant" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeScalarDerivativeFunc.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeScalarDerivativeFunc.kt index 02b5918e..b3ed623a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeScalarDerivativeFunc.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeScalarDerivativeFunc.kt @@ -95,19 +95,23 @@ open class VisualShaderNodeScalarDerivativeFunc( * Container for method_bind pointers for VisualShaderNodeScalarDerivativeFunc */ private object __method_bind { - val getFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeScalarDerivativeFunc".cstr.ptr, - "get_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_function" } - } - val setFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeScalarDerivativeFunc".cstr.ptr, - "set_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_function" } - }} + val getFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeScalarDerivativeFunc".cstr.ptr, + "get_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_function" } + } + } + + val setFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeScalarDerivativeFunc".cstr.ptr, + "set_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_function" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeScalarFunc.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeScalarFunc.kt index ccad3156..4ba6eb92 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeScalarFunc.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeScalarFunc.kt @@ -153,19 +153,23 @@ open class VisualShaderNodeScalarFunc( * Container for method_bind pointers for VisualShaderNodeScalarFunc */ private object __method_bind { - val getFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeScalarFunc".cstr.ptr, - "get_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_function" } - } - val setFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeScalarFunc".cstr.ptr, - "set_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_function" } - }} + val getFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeScalarFunc".cstr.ptr, + "get_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_function" } + } + } + + val setFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeScalarFunc".cstr.ptr, + "set_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_function" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeScalarOp.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeScalarOp.kt index 323f9b7c..f08afd18 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeScalarOp.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeScalarOp.kt @@ -109,19 +109,23 @@ open class VisualShaderNodeScalarOp( * Container for method_bind pointers for VisualShaderNodeScalarOp */ private object __method_bind { - val getOperator: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeScalarOp".cstr.ptr, - "get_operator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_operator" } - } - val setOperator: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeScalarOp".cstr.ptr, - "set_operator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_operator" } - }} + val getOperator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeScalarOp".cstr.ptr, + "get_operator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_operator" } + } + } + + val setOperator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeScalarOp".cstr.ptr, + "set_operator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_operator" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTexture.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTexture.kt index 676dddb4..a7488bb0 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTexture.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTexture.kt @@ -174,47 +174,59 @@ open class VisualShaderNodeTexture( * Container for method_bind pointers for VisualShaderNodeTexture */ private object __method_bind { - val getSource: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTexture".cstr.ptr, - "get_source".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_source" } - } - val getTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTexture".cstr.ptr, - "get_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture" } - } - val getTextureType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTexture".cstr.ptr, - "get_texture_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture_type" } - } - val setSource: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTexture".cstr.ptr, - "set_source".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_source" } - } - val setTexture: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTexture".cstr.ptr, - "set_texture".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture" } - } - val setTextureType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTexture".cstr.ptr, - "set_texture_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture_type" } - }} + val getSource: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTexture".cstr.ptr, + "get_source".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_source" } + } + } + + val getTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTexture".cstr.ptr, + "get_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture" } + } + } + + val getTextureType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTexture".cstr.ptr, + "get_texture_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture_type" } + } + } + + val setSource: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTexture".cstr.ptr, + "set_source".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_source" } + } + } + + val setTexture: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTexture".cstr.ptr, + "set_texture".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture" } + } + } + + val setTextureType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTexture".cstr.ptr, + "set_texture_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture_type" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTextureUniform.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTextureUniform.kt index ea7bf2b5..74361ca3 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTextureUniform.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTextureUniform.kt @@ -141,33 +141,41 @@ open class VisualShaderNodeTextureUniform( * Container for method_bind pointers for VisualShaderNodeTextureUniform */ private object __method_bind { - val getColorDefault: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTextureUniform".cstr.ptr, - "get_color_default".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_color_default" } - } - val getTextureType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTextureUniform".cstr.ptr, - "get_texture_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_texture_type" } - } - val setColorDefault: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTextureUniform".cstr.ptr, - "set_color_default".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_color_default" } - } - val setTextureType: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTextureUniform".cstr.ptr, - "set_texture_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_texture_type" } - }} + val getColorDefault: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTextureUniform".cstr.ptr, + "get_color_default".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_color_default" } + } + } + + val getTextureType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTextureUniform".cstr.ptr, + "get_texture_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_texture_type" } + } + } + + val setColorDefault: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTextureUniform".cstr.ptr, + "set_color_default".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_color_default" } + } + } + + val setTextureType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTextureUniform".cstr.ptr, + "set_texture_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_texture_type" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTransformConstant.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTransformConstant.kt index 8da492e9..9c1b782d 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTransformConstant.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTransformConstant.kt @@ -85,19 +85,23 @@ open class VisualShaderNodeTransformConstant( * Container for method_bind pointers for VisualShaderNodeTransformConstant */ private object __method_bind { - val getConstant: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTransformConstant".cstr.ptr, - "get_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_constant" } - } - val setConstant: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTransformConstant".cstr.ptr, - "set_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_constant" } - }} + val getConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTransformConstant".cstr.ptr, + "get_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_constant" } + } + } + + val setConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTransformConstant".cstr.ptr, + "set_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_constant" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTransformFunc.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTransformFunc.kt index f5f55ff9..3e2504f5 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTransformFunc.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTransformFunc.kt @@ -93,19 +93,23 @@ open class VisualShaderNodeTransformFunc( * Container for method_bind pointers for VisualShaderNodeTransformFunc */ private object __method_bind { - val getFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTransformFunc".cstr.ptr, - "get_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_function" } - } - val setFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTransformFunc".cstr.ptr, - "set_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_function" } - }} + val getFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTransformFunc".cstr.ptr, + "get_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_function" } + } + } + + val setFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTransformFunc".cstr.ptr, + "set_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_function" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTransformMult.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTransformMult.kt index fd7865a7..2996e920 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTransformMult.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTransformMult.kt @@ -97,19 +97,23 @@ open class VisualShaderNodeTransformMult( * Container for method_bind pointers for VisualShaderNodeTransformMult */ private object __method_bind { - val getOperator: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTransformMult".cstr.ptr, - "get_operator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_operator" } - } - val setOperator: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTransformMult".cstr.ptr, - "set_operator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_operator" } - }} + val getOperator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTransformMult".cstr.ptr, + "get_operator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_operator" } + } + } + + val setOperator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTransformMult".cstr.ptr, + "set_operator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_operator" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTransformVecMult.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTransformVecMult.kt index 95972aab..1cc63d0e 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTransformVecMult.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeTransformVecMult.kt @@ -97,19 +97,23 @@ open class VisualShaderNodeTransformVecMult( * Container for method_bind pointers for VisualShaderNodeTransformVecMult */ private object __method_bind { - val getOperator: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTransformVecMult".cstr.ptr, - "get_operator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_operator" } - } - val setOperator: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTransformVecMult".cstr.ptr, - "set_operator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_operator" } - }} + val getOperator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTransformVecMult".cstr.ptr, + "get_operator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_operator" } + } + } + + val setOperator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeTransformVecMult".cstr.ptr, + "set_operator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_operator" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeUniform.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeUniform.kt index d6156841..d70f45fd 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeUniform.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeUniform.kt @@ -67,19 +67,23 @@ open class VisualShaderNodeUniform( * Container for method_bind pointers for VisualShaderNodeUniform */ private object __method_bind { - val getUniformName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeUniform".cstr.ptr, - "get_uniform_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_uniform_name" } - } - val setUniformName: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeUniform".cstr.ptr, - "set_uniform_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_uniform_name" } - }} + val getUniformName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeUniform".cstr.ptr, + "get_uniform_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_uniform_name" } + } + } + + val setUniformName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeUniform".cstr.ptr, + "set_uniform_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_uniform_name" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeVec3Constant.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeVec3Constant.kt index b6aabed7..51e577ad 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeVec3Constant.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeVec3Constant.kt @@ -85,19 +85,23 @@ open class VisualShaderNodeVec3Constant( * Container for method_bind pointers for VisualShaderNodeVec3Constant */ private object __method_bind { - val getConstant: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeVec3Constant".cstr.ptr, - "get_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_constant" } - } - val setConstant: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeVec3Constant".cstr.ptr, - "set_constant".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_constant" } - }} + val getConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeVec3Constant".cstr.ptr, + "get_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_constant" } + } + } + + val setConstant: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeVec3Constant".cstr.ptr, + "set_constant".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_constant" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeVectorDerivativeFunc.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeVectorDerivativeFunc.kt index 1444b3aa..7fb80ef8 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeVectorDerivativeFunc.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeVectorDerivativeFunc.kt @@ -95,19 +95,23 @@ open class VisualShaderNodeVectorDerivativeFunc( * Container for method_bind pointers for VisualShaderNodeVectorDerivativeFunc */ private object __method_bind { - val getFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeVectorDerivativeFunc".cstr.ptr, - "get_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_function" } - } - val setFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeVectorDerivativeFunc".cstr.ptr, - "set_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_function" } - }} + val getFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeVectorDerivativeFunc".cstr.ptr, + "get_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_function" } + } + } + + val setFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeVectorDerivativeFunc".cstr.ptr, + "set_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_function" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeVectorFunc.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeVectorFunc.kt index 053be1b9..bb5cc5fd 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeVectorFunc.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeVectorFunc.kt @@ -159,19 +159,23 @@ open class VisualShaderNodeVectorFunc( * Container for method_bind pointers for VisualShaderNodeVectorFunc */ private object __method_bind { - val getFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeVectorFunc".cstr.ptr, - "get_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_function" } - } - val setFunction: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeVectorFunc".cstr.ptr, - "set_function".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_function" } - }} + val getFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeVectorFunc".cstr.ptr, + "get_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_function" } + } + } + + val setFunction: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeVectorFunc".cstr.ptr, + "set_function".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_function" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeVectorOp.kt b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeVectorOp.kt index 82798b5f..a8dfe80f 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeVectorOp.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/VisualShaderNodeVectorOp.kt @@ -113,19 +113,23 @@ open class VisualShaderNodeVectorOp( * Container for method_bind pointers for VisualShaderNodeVectorOp */ private object __method_bind { - val getOperator: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeVectorOp".cstr.ptr, - "get_operator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_operator" } - } - val setOperator: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeVectorOp".cstr.ptr, - "set_operator".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_operator" } - }} + val getOperator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeVectorOp".cstr.ptr, + "get_operator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_operator" } + } + } + + val setOperator: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("VisualShaderNodeVectorOp".cstr.ptr, + "set_operator".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_operator" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/WeakRef.kt b/godot-kotlin/src/nativeGen/kotlin/godot/WeakRef.kt index 297e8f65..c8119470 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/WeakRef.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/WeakRef.kt @@ -58,11 +58,14 @@ open class WeakRef( * Container for method_bind pointers for WeakRef */ private object __method_bind { - val getRef: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WeakRef".cstr.ptr, - "get_ref".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ref" } - }} + val getRef: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WeakRef".cstr.ptr, + "get_ref".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ref" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/WebRTCDataChannel.kt b/godot-kotlin/src/nativeGen/kotlin/godot/WebRTCDataChannel.kt index 708dc493..12c97a77 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/WebRTCDataChannel.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/WebRTCDataChannel.kt @@ -220,96 +220,122 @@ open class WebRTCDataChannel( * Container for method_bind pointers for WebRTCDataChannel */ private object __method_bind { - val close: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, - "close".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method close" } - } - val getId: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, - "get_id".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_id" } - } - val getLabel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, - "get_label".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_label" } - } - val getMaxPacketLifeTime: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, - "get_max_packet_life_time".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_max_packet_life_time" } - } - val getMaxRetransmits: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, - "get_max_retransmits".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_max_retransmits" } - } - val getProtocol: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, - "get_protocol".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_protocol" } - } - val getReadyState: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, - "get_ready_state".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ready_state" } - } - val getWriteMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, - "get_write_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_write_mode" } - } - val isNegotiated: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, - "is_negotiated".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_negotiated" } - } - val isOrdered: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, - "is_ordered".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_ordered" } - } - val poll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, - "poll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method poll" } - } - val setWriteMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, - "set_write_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_write_mode" } - } - val wasStringPacket: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, - "was_string_packet".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method was_string_packet" } - }} + val close: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, + "close".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method close" } + } + } + + val getId: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, + "get_id".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_id" } + } + } + + val getLabel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, + "get_label".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_label" } + } + } + + val getMaxPacketLifeTime: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, + "get_max_packet_life_time".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_max_packet_life_time" } + } + } + + val getMaxRetransmits: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, + "get_max_retransmits".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_max_retransmits" } + } + } + + val getProtocol: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, + "get_protocol".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_protocol" } + } + } + + val getReadyState: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, + "get_ready_state".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ready_state" } + } + } + + val getWriteMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, + "get_write_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_write_mode" } + } + } + + val isNegotiated: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, + "is_negotiated".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_negotiated" } + } + } + + val isOrdered: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, + "is_ordered".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_ordered" } + } + } + + val poll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, + "poll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method poll" } + } + } + + val setWriteMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, + "set_write_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_write_mode" } + } + } + + val wasStringPacket: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCDataChannel".cstr.ptr, + "was_string_packet".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method was_string_packet" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/WebRTCMultiplayer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/WebRTCMultiplayer.kt index 3f734ae3..ba69cdf3 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/WebRTCMultiplayer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/WebRTCMultiplayer.kt @@ -129,54 +129,68 @@ open class WebRTCMultiplayer( * Container for method_bind pointers for WebRTCMultiplayer */ private object __method_bind { - val addPeer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCMultiplayer".cstr.ptr, - "add_peer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_peer" } - } - val close: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCMultiplayer".cstr.ptr, - "close".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method close" } - } - val getPeer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCMultiplayer".cstr.ptr, - "get_peer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_peer" } - } - val getPeers: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCMultiplayer".cstr.ptr, - "get_peers".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_peers" } - } - val hasPeer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCMultiplayer".cstr.ptr, - "has_peer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_peer" } - } - val initialize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCMultiplayer".cstr.ptr, - "initialize".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method initialize" } - } - val removePeer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCMultiplayer".cstr.ptr, - "remove_peer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method remove_peer" } - }} + val addPeer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCMultiplayer".cstr.ptr, + "add_peer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_peer" } + } + } + + val close: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCMultiplayer".cstr.ptr, + "close".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method close" } + } + } + + val getPeer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCMultiplayer".cstr.ptr, + "get_peer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_peer" } + } + } + + val getPeers: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCMultiplayer".cstr.ptr, + "get_peers".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_peers" } + } + } + + val hasPeer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCMultiplayer".cstr.ptr, + "has_peer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_peer" } + } + } + + val initialize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCMultiplayer".cstr.ptr, + "initialize".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method initialize" } + } + } + + val removePeer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCMultiplayer".cstr.ptr, + "remove_peer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method remove_peer" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/WebRTCPeerConnection.kt b/godot-kotlin/src/nativeGen/kotlin/godot/WebRTCPeerConnection.kt index b350a573..37b3da16 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/WebRTCPeerConnection.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/WebRTCPeerConnection.kt @@ -200,68 +200,86 @@ open class WebRTCPeerConnection( * Container for method_bind pointers for WebRTCPeerConnection */ private object __method_bind { - val addIceCandidate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCPeerConnection".cstr.ptr, - "add_ice_candidate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method add_ice_candidate" } - } - val close: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCPeerConnection".cstr.ptr, - "close".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method close" } - } - val createDataChannel: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCPeerConnection".cstr.ptr, - "create_data_channel".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_data_channel" } - } - val createOffer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCPeerConnection".cstr.ptr, - "create_offer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method create_offer" } - } - val getConnectionState: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCPeerConnection".cstr.ptr, - "get_connection_state".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connection_state" } - } - val initialize: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCPeerConnection".cstr.ptr, - "initialize".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method initialize" } - } - val poll: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCPeerConnection".cstr.ptr, - "poll".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method poll" } - } - val setLocalDescription: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCPeerConnection".cstr.ptr, - "set_local_description".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_local_description" } - } - val setRemoteDescription: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCPeerConnection".cstr.ptr, - "set_remote_description".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_remote_description" } - }} + val addIceCandidate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCPeerConnection".cstr.ptr, + "add_ice_candidate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method add_ice_candidate" } + } + } + + val close: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCPeerConnection".cstr.ptr, + "close".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method close" } + } + } + + val createDataChannel: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCPeerConnection".cstr.ptr, + "create_data_channel".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_data_channel" } + } + } + + val createOffer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCPeerConnection".cstr.ptr, + "create_offer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method create_offer" } + } + } + + val getConnectionState: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCPeerConnection".cstr.ptr, + "get_connection_state".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connection_state" } + } + } + + val initialize: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCPeerConnection".cstr.ptr, + "initialize".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method initialize" } + } + } + + val poll: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCPeerConnection".cstr.ptr, + "poll".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method poll" } + } + } + + val setLocalDescription: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCPeerConnection".cstr.ptr, + "set_local_description".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_local_description" } + } + } + + val setRemoteDescription: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebRTCPeerConnection".cstr.ptr, + "set_remote_description".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_remote_description" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/WebSocketClient.kt b/godot-kotlin/src/nativeGen/kotlin/godot/WebSocketClient.kt index c8ed2ddb..12889c3d 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/WebSocketClient.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/WebSocketClient.kt @@ -180,61 +180,77 @@ open class WebSocketClient( * Container for method_bind pointers for WebSocketClient */ private object __method_bind { - val connectToUrl: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketClient".cstr.ptr, - "connect_to_url".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method connect_to_url" } - } - val disconnectFromHost: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketClient".cstr.ptr, - "disconnect_from_host".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method disconnect_from_host" } - } - val getConnectedHost: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketClient".cstr.ptr, - "get_connected_host".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connected_host" } - } - val getConnectedPort: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketClient".cstr.ptr, - "get_connected_port".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connected_port" } - } - val getTrustedSslCertificate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketClient".cstr.ptr, - "get_trusted_ssl_certificate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_trusted_ssl_certificate" } - } - val isVerifySslEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketClient".cstr.ptr, - "is_verify_ssl_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_verify_ssl_enabled" } - } - val setTrustedSslCertificate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketClient".cstr.ptr, - "set_trusted_ssl_certificate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_trusted_ssl_certificate" } - } - val setVerifySslEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketClient".cstr.ptr, - "set_verify_ssl_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_verify_ssl_enabled" } - }} + val connectToUrl: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketClient".cstr.ptr, + "connect_to_url".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method connect_to_url" } + } + } + + val disconnectFromHost: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketClient".cstr.ptr, + "disconnect_from_host".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method disconnect_from_host" } + } + } + + val getConnectedHost: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketClient".cstr.ptr, + "get_connected_host".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connected_host" } + } + } + + val getConnectedPort: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketClient".cstr.ptr, + "get_connected_port".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connected_port" } + } + } + + val getTrustedSslCertificate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketClient".cstr.ptr, + "get_trusted_ssl_certificate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_trusted_ssl_certificate" } + } + } + + val isVerifySslEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketClient".cstr.ptr, + "is_verify_ssl_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_verify_ssl_enabled" } + } + } + + val setTrustedSslCertificate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketClient".cstr.ptr, + "set_trusted_ssl_certificate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_trusted_ssl_certificate" } + } + } + + val setVerifySslEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketClient".cstr.ptr, + "set_verify_ssl_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_verify_ssl_enabled" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/WebSocketMultiplayerPeer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/WebSocketMultiplayerPeer.kt index cf5edff0..e58e541c 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/WebSocketMultiplayerPeer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/WebSocketMultiplayerPeer.kt @@ -80,19 +80,23 @@ open class WebSocketMultiplayerPeer( * Container for method_bind pointers for WebSocketMultiplayerPeer */ private object __method_bind { - val getPeer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketMultiplayerPeer".cstr.ptr, - "get_peer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_peer" } - } - val setBuffers: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketMultiplayerPeer".cstr.ptr, - "set_buffers".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_buffers" } - }} + val getPeer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketMultiplayerPeer".cstr.ptr, + "get_peer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_peer" } + } + } + + val setBuffers: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketMultiplayerPeer".cstr.ptr, + "set_buffers".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_buffers" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/WebSocketPeer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/WebSocketPeer.kt index bb635939..a71bbbb8 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/WebSocketPeer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/WebSocketPeer.kt @@ -143,61 +143,77 @@ open class WebSocketPeer( * Container for method_bind pointers for WebSocketPeer */ private object __method_bind { - val close: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketPeer".cstr.ptr, - "close".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method close" } - } - val getConnectedHost: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketPeer".cstr.ptr, - "get_connected_host".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connected_host" } - } - val getConnectedPort: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketPeer".cstr.ptr, - "get_connected_port".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_connected_port" } - } - val getWriteMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketPeer".cstr.ptr, - "get_write_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_write_mode" } - } - val isConnectedToHost: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketPeer".cstr.ptr, - "is_connected_to_host".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_connected_to_host" } - } - val setNoDelay: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketPeer".cstr.ptr, - "set_no_delay".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_no_delay" } - } - val setWriteMode: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketPeer".cstr.ptr, - "set_write_mode".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_write_mode" } - } - val wasStringPacket: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketPeer".cstr.ptr, - "was_string_packet".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method was_string_packet" } - }} + val close: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketPeer".cstr.ptr, + "close".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method close" } + } + } + + val getConnectedHost: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketPeer".cstr.ptr, + "get_connected_host".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connected_host" } + } + } + + val getConnectedPort: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketPeer".cstr.ptr, + "get_connected_port".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_connected_port" } + } + } + + val getWriteMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketPeer".cstr.ptr, + "get_write_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_write_mode" } + } + } + + val isConnectedToHost: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketPeer".cstr.ptr, + "is_connected_to_host".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_connected_to_host" } + } + } + + val setNoDelay: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketPeer".cstr.ptr, + "set_no_delay".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_no_delay" } + } + } + + val setWriteMode: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketPeer".cstr.ptr, + "set_write_mode".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_write_mode" } + } + } + + val wasStringPacket: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketPeer".cstr.ptr, + "was_string_packet".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method was_string_packet" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/WebSocketServer.kt b/godot-kotlin/src/nativeGen/kotlin/godot/WebSocketServer.kt index 4af53f82..f2c424a5 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/WebSocketServer.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/WebSocketServer.kt @@ -260,110 +260,140 @@ open class WebSocketServer( * Container for method_bind pointers for WebSocketServer */ private object __method_bind { - val disconnectPeer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, - "disconnect_peer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method disconnect_peer" } - } - val getBindIp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, - "get_bind_ip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_bind_ip" } - } - val getCaChain: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, - "get_ca_chain".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ca_chain" } - } - val getPeerAddress: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, - "get_peer_address".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_peer_address" } - } - val getPeerPort: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, - "get_peer_port".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_peer_port" } - } - val getPrivateKey: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, - "get_private_key".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_private_key" } - } - val getSslCertificate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, - "get_ssl_certificate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_ssl_certificate" } - } - val hasPeer: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, - "has_peer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_peer" } - } - val isListening: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, - "is_listening".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_listening" } - } - val listen: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, - "listen".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method listen" } - } - val setBindIp: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, - "set_bind_ip".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_bind_ip" } - } - val setCaChain: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, - "set_ca_chain".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ca_chain" } - } - val setPrivateKey: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, - "set_private_key".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_private_key" } - } - val setSslCertificate: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, - "set_ssl_certificate".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_ssl_certificate" } - } - val stop: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, - "stop".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method stop" } - }} + val disconnectPeer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, + "disconnect_peer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method disconnect_peer" } + } + } + + val getBindIp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, + "get_bind_ip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_bind_ip" } + } + } + + val getCaChain: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, + "get_ca_chain".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ca_chain" } + } + } + + val getPeerAddress: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, + "get_peer_address".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_peer_address" } + } + } + + val getPeerPort: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, + "get_peer_port".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_peer_port" } + } + } + + val getPrivateKey: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, + "get_private_key".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_private_key" } + } + } + + val getSslCertificate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, + "get_ssl_certificate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_ssl_certificate" } + } + } + + val hasPeer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, + "has_peer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_peer" } + } + } + + val isListening: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, + "is_listening".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_listening" } + } + } + + val listen: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, + "listen".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method listen" } + } + } + + val setBindIp: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, + "set_bind_ip".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_bind_ip" } + } + } + + val setCaChain: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, + "set_ca_chain".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ca_chain" } + } + } + + val setPrivateKey: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, + "set_private_key".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_private_key" } + } + } + + val setSslCertificate: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, + "set_ssl_certificate".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_ssl_certificate" } + } + } + + val stop: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WebSocketServer".cstr.ptr, + "stop".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method stop" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/WindowDialog.kt b/godot-kotlin/src/nativeGen/kotlin/godot/WindowDialog.kt index c2a7bdbb..a0e8e92a 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/WindowDialog.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/WindowDialog.kt @@ -115,40 +115,50 @@ open class WindowDialog( * Container for method_bind pointers for WindowDialog */ private object __method_bind { - val getCloseButton: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WindowDialog".cstr.ptr, - "get_close_button".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_close_button" } - } - val getResizable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WindowDialog".cstr.ptr, - "get_resizable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_resizable" } - } - val getTitle: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WindowDialog".cstr.ptr, - "get_title".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_title" } - } - val setResizable: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WindowDialog".cstr.ptr, - "set_resizable".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_resizable" } - } - val setTitle: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WindowDialog".cstr.ptr, - "set_title".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_title" } - }} + val getCloseButton: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WindowDialog".cstr.ptr, + "get_close_button".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_close_button" } + } + } + + val getResizable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WindowDialog".cstr.ptr, + "get_resizable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_resizable" } + } + } + + val getTitle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WindowDialog".cstr.ptr, + "get_title".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_title" } + } + } + + val setResizable: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WindowDialog".cstr.ptr, + "set_resizable".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_resizable" } + } + } + + val setTitle: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WindowDialog".cstr.ptr, + "set_title".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_title" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/World.kt b/godot-kotlin/src/nativeGen/kotlin/godot/World.kt index b6735a3f..73397df0 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/World.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/World.kt @@ -151,47 +151,61 @@ open class World( * Container for method_bind pointers for World */ private object __method_bind { - val getDirectSpaceState: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World".cstr.ptr, - "get_direct_space_state".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_direct_space_state" } - } - val getEnvironment: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World".cstr.ptr, - "get_environment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_environment" } - } - val getFallbackEnvironment: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World".cstr.ptr, - "get_fallback_environment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_fallback_environment" } - } - val getScenario: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World".cstr.ptr, - "get_scenario".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_scenario" } - } - val getSpace: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World".cstr.ptr, - "get_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_space" } - } - val setEnvironment: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World".cstr.ptr, - "set_environment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_environment" } - } - val setFallbackEnvironment: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World".cstr.ptr, - "set_fallback_environment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_fallback_environment" } - }} + val getDirectSpaceState: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World".cstr.ptr, + "get_direct_space_state".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_direct_space_state" } + } + } + + val getEnvironment: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World".cstr.ptr, + "get_environment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_environment" } + } + } + + val getFallbackEnvironment: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World".cstr.ptr, + "get_fallback_environment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_fallback_environment" } + } + } + + val getScenario: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World".cstr.ptr, + "get_scenario".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_scenario" } + } + } + + val getSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World".cstr.ptr, + "get_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_space" } + } + } + + val setEnvironment: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World".cstr.ptr, + "set_environment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_environment" } + } + } + + val setFallbackEnvironment: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World".cstr.ptr, + "set_fallback_environment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_fallback_environment" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/World2D.kt b/godot-kotlin/src/nativeGen/kotlin/godot/World2D.kt index c5a8a448..9f8cd349 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/World2D.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/World2D.kt @@ -97,23 +97,32 @@ open class World2D( * Container for method_bind pointers for World2D */ private object __method_bind { - val getCanvas: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World2D".cstr.ptr, - "get_canvas".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_canvas" } - } - val getDirectSpaceState: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World2D".cstr.ptr, - "get_direct_space_state".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_direct_space_state" } - } - val getSpace: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World2D".cstr.ptr, - "get_space".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_space" } - }} + val getCanvas: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World2D".cstr.ptr, + "get_canvas".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_canvas" } + } + } + + val getDirectSpaceState: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World2D".cstr.ptr, + "get_direct_space_state".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_direct_space_state" } + } + } + + val getSpace: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("World2D".cstr.ptr, + "get_space".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_space" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/WorldEnvironment.kt b/godot-kotlin/src/nativeGen/kotlin/godot/WorldEnvironment.kt index ee3a2aa7..a5508c88 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/WorldEnvironment.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/WorldEnvironment.kt @@ -75,19 +75,23 @@ open class WorldEnvironment( * Container for method_bind pointers for WorldEnvironment */ private object __method_bind { - val getEnvironment: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WorldEnvironment".cstr.ptr, - "get_environment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_environment" } - } - val setEnvironment: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WorldEnvironment".cstr.ptr, - "set_environment".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_environment" } - }} + val getEnvironment: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WorldEnvironment".cstr.ptr, + "get_environment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_environment" } + } + } + + val setEnvironment: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("WorldEnvironment".cstr.ptr, + "set_environment".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_environment" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/X509Certificate.kt b/godot-kotlin/src/nativeGen/kotlin/godot/X509Certificate.kt index a98044b8..7f705659 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/X509Certificate.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/X509Certificate.kt @@ -69,19 +69,23 @@ open class X509Certificate( * Container for method_bind pointers for X509Certificate */ private object __method_bind { - val load: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("X509Certificate".cstr.ptr, - "load".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method load" } - } - val save: CPointer - get() = Allocator.allocationScope { - val ptr = - checkNotNull(Godot.gdnative.godot_method_bind_get_method)("X509Certificate".cstr.ptr, - "save".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method save" } - }} + val load: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("X509Certificate".cstr.ptr, + "load".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method load" } + } + } + + val save: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("X509Certificate".cstr.ptr, + "save".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method save" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/XMLParser.kt b/godot-kotlin/src/nativeGen/kotlin/godot/XMLParser.kt index 8b9432af..12f7ced7 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/XMLParser.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/XMLParser.kt @@ -253,107 +253,159 @@ open class XMLParser( * Container for method_bind pointers for XMLParser */ private object __method_bind { - val getAttributeCount: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, - "get_attribute_count".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_attribute_count" } - } - val getAttributeName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, - "get_attribute_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_attribute_name" } - } - val getAttributeValue: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, - "get_attribute_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_attribute_value" } - } - val getCurrentLine: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, - "get_current_line".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_current_line" } - } - val getNamedAttributeValue: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, - "get_named_attribute_value".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_named_attribute_value" } - } - val getNamedAttributeValueSafe: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, - "get_named_attribute_value_safe".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_named_attribute_value_safe" } - } - val getNodeData: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, - "get_node_data".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_data" } - } - val getNodeName: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, - "get_node_name".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_name" } - } - val getNodeOffset: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, - "get_node_offset".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_offset" } - } - val getNodeType: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, - "get_node_type".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method get_node_type" } - } - val hasAttribute: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, - "has_attribute".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method has_attribute" } - } - val isEmpty: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, - "is_empty".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_empty" } - } - val open: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, - "open".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method open" } - } - val openBuffer: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, - "open_buffer".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method open_buffer" } - } - val read: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, - "read".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method read" } - } - val seek: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, - "seek".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method seek" } - } - val skipSection: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, - "skip_section".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method skip_section" } - }} + val getAttributeCount: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, + "get_attribute_count".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_attribute_count" } + } + } + + val getAttributeName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, + "get_attribute_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_attribute_name" } + } + } + + val getAttributeValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, + "get_attribute_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_attribute_value" } + } + } + + val getCurrentLine: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, + "get_current_line".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_current_line" } + } + } + + val getNamedAttributeValue: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, + "get_named_attribute_value".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_named_attribute_value" } + } + } + + val getNamedAttributeValueSafe: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, + "get_named_attribute_value_safe".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_named_attribute_value_safe" + } + } + } + + val getNodeData: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, + "get_node_data".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_data" } + } + } + + val getNodeName: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, + "get_node_name".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_name" } + } + } + + val getNodeOffset: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, + "get_node_offset".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_offset" } + } + } + + val getNodeType: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, + "get_node_type".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method get_node_type" } + } + } + + val hasAttribute: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, + "has_attribute".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method has_attribute" } + } + } + + val isEmpty: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, + "is_empty".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_empty" } + } + } + + val open: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, + "open".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method open" } + } + } + + val openBuffer: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, + "open_buffer".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method open_buffer" } + } + } + + val read: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, + "read".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method read" } + } + } + + val seek: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, + "seek".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method seek" } + } + } + + val skipSection: CPointer by lazy { + Allocator.allocationScope { + val ptr = + checkNotNull(Godot.gdnative.godot_method_bind_get_method)("XMLParser".cstr.ptr, + "skip_section".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method skip_section" } + } + } + } } } diff --git a/godot-kotlin/src/nativeGen/kotlin/godot/YSort.kt b/godot-kotlin/src/nativeGen/kotlin/godot/YSort.kt index d46db95b..03e1eecd 100644 --- a/godot-kotlin/src/nativeGen/kotlin/godot/YSort.kt +++ b/godot-kotlin/src/nativeGen/kotlin/godot/YSort.kt @@ -73,17 +73,21 @@ open class YSort( * Container for method_bind pointers for YSort */ private object __method_bind { - val isSortEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("YSort".cstr.ptr, - "is_sort_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method is_sort_enabled" } - } - val setSortEnabled: CPointer - get() = Allocator.allocationScope { - val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("YSort".cstr.ptr, - "set_sort_enabled".cstr.ptr) - requireNotNull(ptr) { "No method_bind found for method set_sort_enabled" } - }} + val isSortEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("YSort".cstr.ptr, + "is_sort_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method is_sort_enabled" } + } + } + + val setSortEnabled: CPointer by lazy { + Allocator.allocationScope { + val ptr = checkNotNull(Godot.gdnative.godot_method_bind_get_method)("YSort".cstr.ptr, + "set_sort_enabled".cstr.ptr) + requireNotNull(ptr) { "No method_bind found for method set_sort_enabled" } + } + } + } } }