├── examples ├── .gitkeep └── proj_example │ ├── .gitkeep │ └── src │ ├── modules │ └── example_module.nim │ └── example.nim ├── src ├── gdextension_nim │ ├── variant │ │ ├── string.nim │ │ └── vector2.nim │ ├── includes.nim │ ├── core │ │ ├── type_info.nim │ │ ├── method_ptrcall.nim │ │ ├── class_db.nim │ │ ├── method_bind.nim │ │ ├── builtin_ptrcall.nim │ │ ├── math.nim │ │ ├── property_info.nim │ │ ├── error_macros.nim │ │ ├── variant.nim │ │ └── global_constants.nim │ ├── classes │ │ ├── t_object.nim │ │ ├── t_node.nim │ │ └── wrapped.nim │ ├── preludes.nim │ ├── internal.nim │ ├── utility_functions.nim │ ├── godot.nim │ └── wrapped_header │ │ └── gdnative_interface.nim └── gdextension_nim.nim ├── tests ├── testproj │ ├── extension_list.cfg │ ├── icon.png │ ├── nim.gdextension │ ├── .gitignore │ ├── project.godot │ └── icon.png.import └── testgde │ ├── nakefile │ ├── testgde.nimble │ ├── nakefile.nim │ └── src │ └── testgde.nim ├── .gitignore ├── gdextension_nim.nimble ├── README.md ├── godot-headers ├── README.md └── godot │ ├── gdnative_interface.h │ └── gdnative_interface.nim └── LICENSE /examples/.gitkeep: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /examples/proj_example/.gitkeep: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /src/gdextension_nim/variant/string.nim: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/testproj/extension_list.cfg: -------------------------------------------------------------------------------- 1 | res://nim.gdextension -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | nimcache/ 2 | nimblecache/ 3 | htmldocs/ 4 | .vscode 5 | .dll 6 | .so -------------------------------------------------------------------------------- /src/gdextension_nim/includes.nim: -------------------------------------------------------------------------------- 1 | 2 | {.pragma: gdnExport, exportc, dynlib, cdecl.} -------------------------------------------------------------------------------- /src/gdextension_nim/core/type_info.nim: -------------------------------------------------------------------------------- 1 | import ../wrapped_header/gdnative_interface 2 | 3 | -------------------------------------------------------------------------------- /src/gdextension_nim/classes/t_object.nim: -------------------------------------------------------------------------------- 1 | import wrapped 2 | 3 | type Object* = ref object of Wrapped -------------------------------------------------------------------------------- /tests/testgde/nakefile: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/hapenia/gdextension-nim/HEAD/tests/testgde/nakefile -------------------------------------------------------------------------------- /tests/testproj/icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/hapenia/gdextension-nim/HEAD/tests/testproj/icon.png -------------------------------------------------------------------------------- /src/gdextension_nim/classes/t_node.nim: -------------------------------------------------------------------------------- 1 | #* this file is test only. We should generate it automatically. 2 | 3 | -------------------------------------------------------------------------------- /src/gdextension_nim/preludes.nim: -------------------------------------------------------------------------------- 1 | import utility_functions as GD 2 | import variant/vector2 3 | import variant/string 4 | import core/error_macros -------------------------------------------------------------------------------- /tests/testproj/nim.gdextension: -------------------------------------------------------------------------------- 1 | [configuration] 2 | 3 | entry_symbol = "exampleLibraryInit" 4 | 5 | [libraries] 6 | 7 | linux.64.debug = "bin/libtestgde.so" 8 | windows.64.debug = "bin/libtestgde.dll" -------------------------------------------------------------------------------- /tests/testproj/.gitignore: -------------------------------------------------------------------------------- 1 | # Godot-specific ignores 2 | .import/ 3 | .godot/ 4 | bin/ 5 | export.cfg 6 | export_presets.cfg 7 | 8 | # Imported translations (automatically generated from CSV files) 9 | *.translation 10 | 11 | # Mono-specific ignores 12 | .mono/ 13 | data_*/ -------------------------------------------------------------------------------- /gdextension_nim.nimble: -------------------------------------------------------------------------------- 1 | # Package 2 | 3 | version = "0.1.0" 4 | author = "hapenia-lans" 5 | description = "Godot 4.0 GDExtension binding for nim language." 6 | license = "MIT" 7 | srcDir = "src" 8 | 9 | 10 | # Dependencies 11 | 12 | requires "nim >= 1.6.6" 13 | -------------------------------------------------------------------------------- /src/gdextension_nim/internal.nim: -------------------------------------------------------------------------------- 1 | import wrapped_header/gdnative_interface 2 | 3 | var 4 | minimumInitializationLevel*: GDNativeInitializationLevel 5 | gdnInterface*: ptr GDNativeInterface 6 | library*: GDNativeExtensionClassLibraryPtr 7 | initialization*: ptr GDNativeInitialization 8 | token*: pointer = nil -------------------------------------------------------------------------------- /src/gdextension_nim/core/method_ptrcall.nim: -------------------------------------------------------------------------------- 1 | 2 | 3 | template MAKE_PTRARG(t: typedesc): untyped = 4 | 5 | proc convert*(pPtr: pointer): t = 6 | result = cast[ptr t](pPtr)[] 7 | 8 | proc encode*(pVal: t, pPtr: pointer): void = 9 | cast[ptr t](pPtr)[] = pVal 10 | 11 | 12 | MAKE_PTRARG bool 13 | MAKE_PTRARG uint8 -------------------------------------------------------------------------------- /tests/testgde/testgde.nimble: -------------------------------------------------------------------------------- 1 | # Package 2 | 3 | version = "0.1.0" 4 | author = "hapenia-lans" 5 | description = "A new awesome nimble package" 6 | license = "MIT" 7 | srcDir = "src" 8 | bin = @["testgde"] 9 | 10 | 11 | # Dependencies 12 | 13 | requires "nim >= 1.6.6" 14 | requires "gdextension_nim" -------------------------------------------------------------------------------- /src/gdextension_nim/core/class_db.nim: -------------------------------------------------------------------------------- 1 | import ../wrapped_header/gdnative_interface 2 | 3 | type 4 | MethodDefinition* {.bycopy.} = object 5 | name: string 6 | args: seq[cstring] 7 | PropertySetget* {.bycopy.} = object 8 | index: int 9 | setter, getter: cstring 10 | 11 | 12 | var current_level: GDNativeInitializationLevel 13 | 14 | 15 | -------------------------------------------------------------------------------- /src/gdextension_nim.nim: -------------------------------------------------------------------------------- 1 | # This is just an example to get you started. A typical library package 2 | # exports the main API in this file. Note that you cannot rename this file 3 | # but you can remove it if you wish. 4 | 5 | import gdextension_nim/godot 6 | import gdextension_nim/core/variant 7 | include gdextension_nim/includes 8 | 9 | export gdnative_interface 10 | export godot 11 | export variant 12 | 13 | -------------------------------------------------------------------------------- /src/gdextension_nim/core/method_bind.nim: -------------------------------------------------------------------------------- 1 | import ../wrapped_header/gdnative_interface 2 | import variant 3 | 4 | 5 | type MethodBind* = object 6 | name: cstring 7 | instanceClass: cstring 8 | argCount: int 9 | hintFlags: uint32 10 | isStatic, isConst, hasReturn, isVararg: bool 11 | argNames: seq[cstring] 12 | argTypes: ptr GDNativeVariantType 13 | defaultArguments: seq[GodotVariant] 14 | 15 | 16 | -------------------------------------------------------------------------------- /examples/proj_example/src/modules/example_module.nim: -------------------------------------------------------------------------------- 1 | import gdextension_nim 2 | 3 | 4 | proc initializeExampleModule*(pLevel: ModuleInitializationLevel) = 5 | if pLevel != milScene: 6 | return 7 | # classDb.registerClass[Example]() 8 | 9 | 10 | proc uninitializeExampleModule*(pLevel: ModuleInitializationLevel) = 11 | if pLevel != milScene: 12 | return 13 | # classDb.unRegisterClass[Example]() 14 | 15 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # gdextension-nim 2 | 3 | Godot 4.0 GDExtension binding for nim language. It's still work in progress. 4 | 5 | ## Dependencies 6 | 7 | - Godot 4.0 8 | - Nake 9 | 10 | ## Usage 11 | 12 | ### Steps 13 | 14 | 1. Clone the project. 15 | 2. Open the project folder and run `nimble develop` to make the library visible. 16 | 3. Open `tests/testgde` folder and `nake build`, then generated dynlib will be putted into `testproj` and you can open it by Godot 4.0. 17 | -------------------------------------------------------------------------------- /tests/testproj/project.godot: -------------------------------------------------------------------------------- 1 | ; Engine configuration file. 2 | ; It's best edited using the editor UI and not directly, 3 | ; since the parameters that go here are not all obvious. 4 | ; 5 | ; Format: 6 | ; [section] ; section goes between [] 7 | ; param=value ; assign values to parameters 8 | 9 | config_version=5 10 | 11 | [application] 12 | 13 | config/name="Testproj" 14 | config/features=PackedStringArray("4.0", "Vulkan Clustered") 15 | config/icon="res://icon.png" 16 | -------------------------------------------------------------------------------- /tests/testgde/nakefile.nim: -------------------------------------------------------------------------------- 1 | import nake; 2 | import strformat; 3 | 4 | const 5 | GodotProjectPath = "../testproj" 6 | GeneratedBinDirName = "bin" 7 | Entry = "src/testgde" 8 | 9 | 10 | task "gen", "generate binding": 11 | #todo: add bindgen 12 | discard 13 | 14 | task "build", "compile your nim extension into dynamic library.": 15 | # discard execShellCmd fmt"nim c {Entry} --mm:orc --app:lib -o:" & GodotProjectPath/DynlibName 16 | shell fmt"nim c --mm:orc --app:lib --outdir:{GodotProjectPath/GeneratedBinDirName} {Entry}" 17 | -------------------------------------------------------------------------------- /examples/proj_example/src/example.nim: -------------------------------------------------------------------------------- 1 | import gdextension_nim/godot as godot 2 | include gdextension_nim/includes 3 | 4 | import modules/example_module as m 5 | 6 | 7 | # ------------------------------ EXPORT CDYNLIB ------------------------------ # 8 | 9 | proc exampleLibraryInit*(pInterface: ptr GDNativeInterface, pLibrary: GDNativeExtensionClassLibraryPtr, rInitialization: ptr GDNativeInitialization): GDNativeBool {.gdnExport.} = 10 | godot.registerInitializer(m.initializeExampleModule) 11 | godot.registerTerminator(m.uninitializeExampleModule) 12 | godot.setMinimumLibraryInitializationLevel(ModuleInitializationLevel.milScene) 13 | result = godot.init(pInterface, pLibrary, rInitialization) 14 | 15 | -------------------------------------------------------------------------------- /godot-headers/README.md: -------------------------------------------------------------------------------- 1 | # godot-headers 2 | 3 | This repository contains C headers for 4 | [**Godot Engine**](https://github.com/godotengine/godot)'s *GDNative Extensions* API. 5 | 6 | ## Updating Headers 7 | 8 | If the current branch is not up-to-date for your needs, or if you want to sync 9 | the headers with your own modified version of Godot, here is the update 10 | procedure used to sync this repository with upstream releases: 11 | 12 | - Compile [Godot Engine](https://github.com/godotengine/godot) at the specific 13 | version/commit which you are using. 14 | - Use the compiled executable to generate the `extension_api.json` file with: 15 | `godot --dump-extension-api extension_api.json` 16 | - Copy the file `core/extension/gdnative_interface.h` to `godot` 17 | -------------------------------------------------------------------------------- /src/gdextension_nim/utility_functions.nim: -------------------------------------------------------------------------------- 1 | import godot 2 | import internal 3 | import core/variant 4 | 5 | 6 | proc printInternal(args: varargs[ptr GodotVariantObj], argCount: int) = 7 | #* This for debug only. Should be generated automatically. 8 | var fun = gdnInterface.variant_get_ptr_utility_function("print", 2648703342); 9 | # CHECK_METHOD_BIND(fun) 10 | var 11 | ret = Variant() 12 | pRet = addr ret[] 13 | pArg = cast[GDNativeTypePtr](args[0]) 14 | fun( 15 | pRet, 16 | addr pArg, 17 | cint(argCount) 18 | ) 19 | 20 | 21 | proc print*(args: varargs[GodotVariant]): void = 22 | # TODO: rewrite this using `template` 23 | var a: seq[ptr GodotVariantObj] = @[] 24 | for i in args: a.add(unsafeAddr(i[])) 25 | printInternal(a.toOpenArray(0, a.len()), a.len()) -------------------------------------------------------------------------------- /tests/testproj/icon.png.import: -------------------------------------------------------------------------------- 1 | [remap] 2 | 3 | importer="texture" 4 | type="CompressedTexture2D" 5 | uid="uid://b5lc5myy1blsf" 6 | path="res://.godot/imported/icon.png-487276ed1e3a0c39cad0279d744ee560.ctex" 7 | metadata={ 8 | "vram_texture": false 9 | } 10 | 11 | [deps] 12 | 13 | source_file="res://icon.png" 14 | dest_files=["res://.godot/imported/icon.png-487276ed1e3a0c39cad0279d744ee560.ctex"] 15 | 16 | [params] 17 | 18 | compress/mode=0 19 | compress/lossy_quality=0.7 20 | compress/hdr_compression=1 21 | compress/bptc_ldr=0 22 | compress/normal_map=0 23 | compress/channel_pack=0 24 | mipmaps/generate=false 25 | mipmaps/limit=-1 26 | roughness/mode=0 27 | roughness/src_normal="" 28 | process/fix_alpha_border=true 29 | process/premult_alpha=false 30 | process/normal_map_invert_y=false 31 | process/hdr_as_srgb=false 32 | process/hdr_clamp_exposure=false 33 | process/size_limit=0 34 | detect_3d/compress_to=1 35 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | # MIT License 2 | 3 | Copyright (c) 2022 Hapenia-Lans 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /src/gdextension_nim/core/builtin_ptrcall.nim: -------------------------------------------------------------------------------- 1 | import ../wrapped_header/gdnative_interface 2 | import sequtils, sugar 3 | 4 | 5 | when not defined(GODOT_NIM_BUILTIN_PTRCALL): 6 | const GODOT_NIM_BUILTIN_PTRCALL* = true 7 | 8 | 9 | template callBuiltinConstructor*[C](constructor: GDNativePtrConstructor, base: GDNativeTypePtr, args: varargs[typed]): untyped = 10 | var call_args: array[GDNativeTypePtr, args.len()] = array(a.map(x => addr x)) 11 | constructor(base, addr call_args[0]) 12 | 13 | 14 | template callBuiltinMethodPtrRet*[T](met: GDNativePtrBuiltInMethod, base: GDNativeTypePtr, args: varargs[typed]): T = 15 | var call_args: array[GDNativeTypePtr, args.len()] = array(a.map(x => addr x)) 16 | met(base, addr call_args, addr result, args.len()) 17 | 18 | 19 | template callBuiltinMethodPtrNoRet*(met: GDNativePtrBuiltinMethod, base: GDNativeTypePtr, args: varargs[typed]): void = 20 | var call_args: array[GDNativeTypePtr, args.len()] = array(a.map(x => addr x)) 21 | met(base, addr call_args[0], nil, args.len()) 22 | 23 | 24 | template callBuiltinOperatorPtr*[T](op: GDNativePtrOperatorEvaluator, left: GDNativeTypePtr, right: GDNativeTypePtr): T = 25 | op(left, right, addr result) 26 | 27 | 28 | template callBuiltinPtrGetter*[T](getter: GDNativePtrGetter, base: GDNativeTypePtr): T = 29 | getter(base, addr result) 30 | 31 | 32 | -------------------------------------------------------------------------------- /tests/testgde/src/testgde.nim: -------------------------------------------------------------------------------- 1 | import gdextension_nim as godot 2 | include gdextension_nim/includes 3 | include gdextension_nim/preludes 4 | 5 | 6 | proc initializeModule(lvl: ModuleInitializationLevel): void = 7 | echo "My GDExtension initializing, level = " & $lvl 8 | # var v = Variant(Vec2(10,2)) 9 | # GD.print(v) 10 | # GD.print(Variant(true)) 11 | if lvl == ModuleInitializationLevel.milEditor: 12 | errPrintError("exampleLibraryInit", "testgde.nim", "Test warning", "A test warning", 23, true) 13 | errPrintError("exampleLibraryInit", "testgde.nim", "Test error", "A test error", 23, false) 14 | 15 | 16 | proc deInitializeModule(lvl: ModuleInitializationLevel): void = 17 | echo "My GDExtension deinitializing, level = " & $lvl 18 | # GD.print(Variant(false)) 19 | 20 | 21 | proc exampleLibraryInit(pInterface: ptr GDNativeInterface, pLibrary: GDNativeExtensionClassLibraryPtr, rInitialization: ptr GDNativeInitialization): GDNativeBool {.gdnExport.} = 22 | godot.init( 23 | args = (pInterface, pLibrary, rInitialization), 24 | callbacks = (initializeModule, deInitializeModule) 25 | ) 26 | #* these works fine :) 27 | # errPrintError("exampleLibraryInit", "testgde.nim", "Test warning", "A test warning", 23, true) 28 | # errPrintError("exampleLibraryInit", "testgde.nim", "Test error", "A test error", 23, false) 29 | return 1 30 | 31 | -------------------------------------------------------------------------------- /src/gdextension_nim/core/math.nim: -------------------------------------------------------------------------------- 1 | import std/math 2 | export math 3 | 4 | ### Some math functions does not exists in nim's std library. 5 | 6 | const 7 | CMP_EPSILON* = 0.00001 8 | CMP_EPSILON2* = CMP_EPSILON^2 9 | UNIT_EPSILON* = 0.001 10 | 11 | 12 | proc isEqualApprox*(a, b: float): bool {.inline.} = 13 | if a == b: return true 14 | var tol = CMP_EPSILON * abs(a) 15 | if tol < CMP_EPSILON: tol = CMP_EPSILON 16 | result = abs(a-b) < tol 17 | 18 | 19 | proc isEqualApprox*(a, b, tolerance: float): bool {.inline.} = 20 | if a == b: return true 21 | result = abs(a-b) < tolerance 22 | 23 | 24 | proc isZeroApprox*(s: float): bool = abs(s) < CMP_EPSILON 25 | 26 | 27 | proc sign*[T](x: T): T = 28 | cast[T](if x < 0: -1 else: 1) 29 | 30 | 31 | proc fposmod*(x, y: float): float = 32 | result = floorMod(x, y) 33 | if (result < 0 and y > 0) or (result > 0 and y < 0): 34 | result += y 35 | 36 | 37 | proc snapped*(value, step: float): float {.inline.} = 38 | result = value 39 | if step != 0: 40 | result = floor(value/step + 0.5) * step 41 | 42 | 43 | proc lerp*(minv, maxv, t: float): float {.inline.}= 44 | minv + t * (maxv - minv) 45 | 46 | 47 | proc cubicInterpolate*(fromvalue,tovalue,pre,post,weight: float): float {.inline.} = 48 | result = 0.5 * ( 49 | (fromvalue * 2) + 50 | (-pre + tovalue) * weight + 51 | (2.0*pre - 5.0*fromvalue + 4.0*tovalue - post) * weight^2 + 52 | (-pre + 3.0*fromvalue - 3.0*tovalue + post) * weight^3 53 | ) 54 | 55 | -------------------------------------------------------------------------------- /src/gdextension_nim/core/property_info.nim: -------------------------------------------------------------------------------- 1 | import ../wrapped_header/gdnative_interface 2 | from variant import Type 3 | from global_constants import PropertyHint, PropertyUsageFlags 4 | 5 | type PropertyInfo* = object 6 | `type`*: Type 7 | name*: cstring 8 | className*: cstring 9 | hint*: PropertyHint 10 | hintString*: cstring 11 | usage*: PropertyUsageFlags 12 | 13 | 14 | proc getGDNativePropertyInfo*(self: PropertyInfo): GDNativePropertyInfo = 15 | result = GDNativePropertyInfo( 16 | `type`: uint32 self.`type`, 17 | name: self.name, 18 | hint: uint32 self.hint, 19 | hint_string: self.hintString, 20 | class_name: self.className, 21 | usage: uint32 self.usage, 22 | ) 23 | 24 | 25 | proc newPropertyInfo*(pType: Type, pName: cstring, pHint: PropertyHint = PROPERTY_HINT_NONE, pHintString: cstring = "", pUsage = PROPERTY_USAGE_DEFAULT, pClassName: cstring = ""): auto = 26 | result = PropertyInfo( 27 | `type`: Type(pType), 28 | name: pName, 29 | hint: pHint, 30 | hintString: pHintString, 31 | usage: pUsage, 32 | className: pClassName, 33 | ) 34 | if result.hint == PROPERTY_HINT_RESOURCE_TYPE: 35 | result.className = pHintString 36 | else: 37 | result.className = pClassName 38 | 39 | 40 | proc newPropertyInfo*(pType: GDNativeVariantType, pName: cstring, pHint: PropertyHint = PROPERTY_HINT_NONE, pHintString: cstring = "", pUsage: PropertyUsageFlags = PROPERTY_USAGE_DEFAULT, pClassName: cstring = ""): auto = 41 | newPropertyInfo( 42 | pType = Type(pType), 43 | pName = pName, 44 | pHint = pHint, 45 | pHintString = pHintString, 46 | pUsage = pUsage, 47 | pClassName = pClassName, 48 | ) 49 | 50 | -------------------------------------------------------------------------------- /src/gdextension_nim/godot.nim: -------------------------------------------------------------------------------- 1 | 2 | import wrapped_header/gdnative_interface 3 | import internal 4 | import core/variant as variant 5 | include includes 6 | 7 | export gdnative_interface 8 | export variant 9 | 10 | 11 | type 12 | ModuleInitializationLevel* = enum 13 | milCore = GDNATIVE_INITIALIZATION_CORE, 14 | milServers = GDNATIVE_INITIALIZATION_SERVERS, 15 | milScene = GDNATIVE_INITIALIZATION_SCENE, 16 | milEditor = GDNATIVE_INITIALIZATION_EDITOR, 17 | 18 | Callback* = proc(lvl: ModuleInitializationLevel): void {.nimcall.} 19 | 20 | InitCallbacks* = tuple 21 | initializeCallback, deinitializeCallback: Callback 22 | 23 | InitArguments* = tuple 24 | pInterface: ptr GDNativeInterface 25 | pLibrary: GDNativeExtensionClassLibraryPtr 26 | rInitialization: ptr GDNativeInitialization 27 | 28 | 29 | type GDNativeIntializeDefect* = object of Defect 30 | 31 | 32 | var g: InitCallbacks 33 | 34 | 35 | 36 | proc initializeLevel(userdata: pointer, pLevel: GDNativeInitializationLevel): void {.gdnExport.} = 37 | let cb = g.initializeCallback 38 | if not cb.isNil(): 39 | cb cast[ModuleInitializationLevel](pLevel) 40 | 41 | 42 | proc deinitializeLevel(userdata: pointer, pLevel: GDNativeInitializationLevel): void {.gdnExport.} = 43 | let cb = g.deinitializeCallback 44 | if not cb.isNil(): 45 | cb cast[ModuleInitializationLevel](pLevel) 46 | 47 | 48 | proc init*(args: InitArguments, callbacks: InitCallbacks): void = 49 | (gdnInterface, library, token) = args 50 | args.rInitialization.initialize = initializeLevel 51 | args.rInitialization.deinitialize = deinitializeLevel 52 | args.rInitialization.minimum_initialization_level = minimumInitializationLevel 53 | g = callbacks 54 | 55 | #* init all things here 56 | variant.initBindings() 57 | 58 | 59 | proc setMinimumLibraryInitializationLevel*(pLevel: ModuleInitializationLevel): void = 60 | minimumInitializationLevel = cast[GDNativeInitializationLevel](pLevel) 61 | 62 | -------------------------------------------------------------------------------- /src/gdextension_nim/core/error_macros.nim: -------------------------------------------------------------------------------- 1 | import ../internal 2 | import std/strformat 3 | 4 | 5 | proc errPrintError*(pFunction, pFile, pError, pMessage: cstring, pLine: int32, pIsWarning: bool): void = 6 | if pIsWarning: 7 | gdnInterface.print_warning(pMessage, pFunction, pFile, pLine) 8 | else: 9 | gdnInterface.print_error(pMessage, pFunction, pFile, pLine) 10 | 11 | 12 | proc errPrintError*(pFunction, pFile, pError: cstring, pLine: int32, pIsWarning: bool): void = 13 | errPrintError( 14 | pFunction = pFunction, 15 | pFile = pFile, 16 | pLine = pLine, 17 | #* INFO: From `godot-cpp`: errPrintError only output pMessage so swapped. 18 | pError = "", 19 | pMessage = pError, 20 | pIsWarning = pIsWarning 21 | ) 22 | 23 | 24 | proc errPrintError*(pFunction, pFile: cstring, pLine: int32, pError: cstring, pIsWarning: bool): void = 25 | errPrintError( 26 | pFunction = pFunction, 27 | pFile = pFile, 28 | pLine = pLine, 29 | pError = "", 30 | pMessage = pError, 31 | pIsWarning = pIsWarning 32 | ) 33 | 34 | 35 | proc errPrintIndexError*(pFunction, pFile, pIndexStr, pSizeStr: cstring, pMessage: string, pLine: int32, pIndex, pSize: int64, fatal: bool) = 36 | let str = block: 37 | var res = fmt"Index {pIndexStr} = {pIndex} is out of bounds ({pSizeStr} = {pSize})." 38 | if fatal: "FATAL: " & res 39 | else: res 40 | errPrintError( 41 | pFunction = pFunction, 42 | pFile = pFile, 43 | pLine = pLine, 44 | pMessage = cstring(str), 45 | pError = pMessage, 46 | pIsWarning = false 47 | ) 48 | # let str = "Index " & $pIndexStr & " = " & $pIndex & " is out of bounds (" 49 | 50 | 51 | template ERR_FAIL_INDEX*(mIndex, mSize: int64) = 52 | if mIndex < 0 or mIndex >= mSize: 53 | errPrintIndexError( 54 | pFunction = FUNCTION_STR, 55 | pFile = FILE, 56 | pLine = LINE, 57 | pIndex = mIndex, 58 | pSize = mSize, 59 | pIndexStr = $mIndex, 60 | pSizeStr = $mSize, 61 | pFatal = false 62 | ) 63 | 64 | # TODO: Append other err templates 65 | -------------------------------------------------------------------------------- /src/gdextension_nim/classes/wrapped.nim: -------------------------------------------------------------------------------- 1 | import ../wrapped_header/gdnative_interface 2 | import ../internal as internal 3 | import ../core/variant 4 | import ../core/property_info 5 | 6 | type Wrapped* = ref object of RootObj 7 | plist: ptr GDNativePropertyInfo 8 | plistSize: uint32 9 | owner*: pointer 10 | 11 | method getExtensionClass(self: Wrapped): string {.base.} = "" 12 | 13 | 14 | method getBindingCallbacks(self: Wrapped): ptr GDNativeInstanceBindingCallbacks {.base.} = nil 15 | 16 | 17 | method notification(self: Wrapped, pWhat: int): void {.base.} = discard 18 | 19 | 20 | # proc set(self: Wrapped, pname: StringName, pProperty: GodotVariant): bool = false 21 | 22 | 23 | # proc get(self: Wrapped, pname: StringName, rProperty: GodotVariant): bool = false 24 | 25 | 26 | # proc getPropertyList(self: Wrapped, pList: var Seq[PropertyInfo]): void 27 | 28 | 29 | # proc propertyCanRevert(self: Wrapped, pName: StringName): bool = false 30 | 31 | 32 | # proc propertyGetRevert(self: Wrapped, pName: StringName, rProperty: GodotVariant): bool = false 33 | 34 | 35 | 36 | method notificationBind(self: Wrapped, pInstance: GDExtensionClassInstancePtr, pWhat: int32): void {.base.} = discard 37 | 38 | 39 | proc setBind*(pInstance: GDExtensionClassInstancePtr, pName: GDNativeStringNamePtr, pValue: GDNativeVariantPtr): GDNativeBool = uint8 false 40 | 41 | 42 | proc getBind*(pInstance: GDExtensionClassInstancePtr, pName: GDNativeStringNamePtr, pValue: GDNativeVariantPtr): GDNativeBool = uint8 false 43 | 44 | 45 | proc getPropertyListBind*(pInstance: GDExtensionClassInstancePtr, rCount: uint32): ptr GDNativePropertyInfo = nil 46 | 47 | 48 | proc freePropertyListBind*(pInstance: GDExtensionClassInstancePtr, pList: ptr GDNativePropertyInfo): void = discard 49 | 50 | 51 | proc propertyCanRevertBind*(pInstance: GDExtensionClassInstancePtr, pList: ptr GDNativePropertyInfo): GDNativeBool = uint8 false 52 | 53 | 54 | proc propertyGetRevertBind*(pInstance: GDExtensionClassInstancePtr, pName: GDNativeStringNamePtr, rRet: GDNativeVariantPtr): GDNativeBool = uint8 false 55 | 56 | 57 | # proc toStringBind(pInstance: GDExtensionClassInstancePtr, rOut: GDNativeStringPtr): void 58 | 59 | 60 | method postInitialize*(self: Wrapped): void {.base.} = 61 | let extensionClass = self.getExtensionClass 62 | if extensionClass != "": 63 | internal.gdnInterface.object_set_instance(self.owner, extensionClass, addr self[]) 64 | 65 | internal.gdnInterface.object_set_instance_binding(self.owner, internal.token, addr self[], self.getBindingCallbacks()) 66 | 67 | 68 | proc getClassStatic*(): string = "Wrapped" 69 | 70 | 71 | proc getInstanceID*(): uint64 = 0 72 | 73 | 74 | proc allocAndCopyCstr*(pStr: cstring): cstring = 75 | var size = pStr.len + 1 76 | result = cast[cstring](alloc(size)) 77 | copyMem(result, pStr, size) 78 | 79 | 80 | proc toString*(self: Wrapped): string = "[" & $get_class_static() & ":" & $getInstanceID() & "]" 81 | 82 | 83 | proc `$`*(self: Wrapped): string = self.toString() 84 | 85 | 86 | proc newWrapped*(pGodotClass: cstring): Wrapped = 87 | result = new Wrapped 88 | result.owner = internal.gdnInterface.classdb_construct_object(pGodotClass) 89 | 90 | 91 | # proc newWrapped(pGodotObject: ptr GodotObject): Wrapped = 92 | # _owner = pGodotObject 93 | 94 | 95 | # proc postInitializeHandler(self, pWrapped: Wrapped): void = 96 | # pWrapped.postInitialize() 97 | -------------------------------------------------------------------------------- /src/gdextension_nim/core/variant.nim: -------------------------------------------------------------------------------- 1 | 2 | import ../internal 3 | import ../wrapped_header/gdnative_interface 4 | import method_ptrcall 5 | 6 | import ../variant/[vector2] 7 | 8 | type 9 | Type* = enum 10 | NIL, 11 | 12 | # atomic types 13 | BOOL, 14 | INT, 15 | FLOAT, 16 | STRING, 17 | 18 | # math types 19 | VECTOR2, 20 | VECTOR2I, 21 | RECT2, 22 | RECT2I, 23 | VECTOR3, 24 | VECTOR3I, 25 | TRANSFORM2D, 26 | VECTOR4, 27 | VECTOR4I, 28 | PLANE, 29 | QUATERNION, 30 | AABB, 31 | BASIS, 32 | TRANSFORM3D, 33 | PROJECTION, 34 | 35 | # misc types 36 | COLOR, 37 | STRING_NAME, 38 | NODE_PATH, 39 | RID, 40 | OBJECT, 41 | CALLABLE, 42 | SIGNAL, 43 | DICTIONARY, 44 | ARRAY, 45 | 46 | # typed arrays 47 | PACKED_BYTE_ARRAY, 48 | PACKED_INT32_ARRAY, 49 | PACKED_INT64_ARRAY, 50 | PACKED_FLOAT32_ARRAY, 51 | PACKED_FLOAT64_ARRAY, 52 | PACKED_STRING_ARRAY, 53 | PACKED_VECTOR2_ARRAY, 54 | PACKED_VECTOR3_ARRAY, 55 | PACKED_COLOR_ARRAY, 56 | 57 | VARIANT_MAX, 58 | 59 | 60 | Operator* = enum 61 | # comparison 62 | OP_EQUAL, 63 | OP_NOT_EQUAL, 64 | OP_LESS, 65 | OP_LESS_EQUAL, 66 | OP_GREATER, 67 | OP_GREATER_EQUAL, 68 | # mathematic 69 | OP_ADD, 70 | OP_SUBTRACT, 71 | OP_MULTIPLY, 72 | OP_DIVIDE, 73 | OP_NEGATE, 74 | OP_POSITIVE, 75 | OP_MODULE, 76 | # bitwise 77 | OP_SHIFT_LEFT, 78 | OP_SHIFT_RIGHT, 79 | OP_BIT_AND, 80 | OP_BIT_OR, 81 | OP_BIT_XOR, 82 | OP_BIT_NEGATE, 83 | # logic 84 | OP_AND, 85 | OP_OR, 86 | OP_XOR, 87 | OP_NOT, 88 | # containment 89 | OP_IN, 90 | OP_MAX, 91 | 92 | 93 | type 94 | GodotVariantObj* = array[24, byte] 95 | GodotVariant* = ref GodotVariantObj 96 | 97 | var 98 | fromTypeConstructor: array[VARIANT_MAX,GDNativeVariantFromTypeConstructorFunc] 99 | toTypeConstructor: array[VARIANT_MAX,GDNativeTypeFromVariantConstructorFunc] 100 | 101 | 102 | proc initBindings*(): void = 103 | for i in BOOL..`*(v1, v2: Vector2): bool = 120 | if v1.x == v2.x: (v1.y > v2.y) else: (v1.x > v2.x) 121 | 122 | 123 | proc `<=`*(v1, v2: Vector2): bool = 124 | if v1.x == v2.x: (v1.y <= v2.y) else: (v1.x < v2.x) 125 | 126 | 127 | proc `>=`*(v1, v2: Vector2): bool = 128 | if v1.x == v2.x: (v1.y >= v2.y) else: (v1.x > v2.x) 129 | 130 | 131 | proc setAll*(vec: var Vector2; pValue: float): void {.inline.} = 132 | vec.x = pValue 133 | vec.y = pValue 134 | 135 | 136 | proc length*(vec: Vector2): float {.inline.} = sqrt(vec.x^2 + vec.y^2) 137 | 138 | 139 | proc lengthSquared*(vec: Vector2): float {.inline.} = vec.x^2 + vec.y^2 140 | 141 | 142 | proc minAxisIndex*(vec: Vector2): Axis {.inline.} = 143 | if vec.x < vec.y: AxisX else: AxisY 144 | 145 | 146 | proc maxAxisIndex*(vec: Vector2): Axis {.inline.} = 147 | if vec.x > vec.y: AxisX else: AxisY 148 | 149 | 150 | proc normalize*(vec: var Vector2): void = 151 | let l = vec.x^2 + vec.y^2 152 | if l != 0: 153 | let t = sqrt(l) 154 | vec /= t 155 | 156 | 157 | proc normalized*(vec: Vector2): Vector2 = 158 | result = vec 159 | result.normalize() 160 | 161 | 162 | proc isNormalized*(vec: Vector2): bool = 163 | isEqualApprox(vec.lengthSquared(), 1, UNIT_EPSILON) 164 | 165 | 166 | proc limitLength*(vec: Vector2, pLen: float = 1): Vector2 = 167 | let l = vec.length() 168 | result = vec 169 | if l > 0 and pLen < l: 170 | result /= l 171 | result *= pLen; 172 | 173 | 174 | proc min*(a, b: Vector2): Vector2 = 175 | result = Vector2( 176 | x: min(a.x, b.x), 177 | y: min(a.y, b.y) 178 | ) 179 | 180 | 181 | proc max*(a, b: Vector2): Vector2 = 182 | result = Vector2( 183 | x: max(a.x, b.x), 184 | y: max(a.y, b.y) 185 | ) 186 | 187 | 188 | proc distanceTo*(a, b: Vector2): float = 189 | sqrt((a.x-b.x)^2 + (a.y-b.y)^2) 190 | 191 | 192 | proc distanceSquaredTo*(a, b: Vector2): float = 193 | (a.x-b.x)^2 + (a.y-b.y)^2 194 | 195 | 196 | proc dot*(a, b: Vector2): float = 197 | a.x * b.x + a.y * b.y 198 | 199 | 200 | proc cross*(a, b: Vector2): float = 201 | a.x * b.y - a.y * b.x 202 | 203 | 204 | proc angleTo*(a, b: Vector2): float = 205 | arctan2(cross(a, b), dot(a, b)) 206 | 207 | 208 | proc angle*(v: Vector2): float = arctan2(v.y, v.x) 209 | 210 | 211 | proc angleToPoint*(a, b: Vector2): float = 212 | (b-a).angle() 213 | 214 | 215 | proc abs*(v: Vector2): Vector2 {.inline.} = 216 | Vector2(x: abs(v.x), y: abs(v.y)) 217 | 218 | 219 | proc floor*(v: Vector2): Vector2 = 220 | Vector2(x: floor(v.x), y: floor(v.y)) 221 | 222 | 223 | proc ceil*(v: Vector2): Vector2 = 224 | Vector2(x: ceil(v.x), y: ceil(v.y)) 225 | 226 | 227 | proc round*(v: Vector2): Vector2 = 228 | Vector2(x: round(v.x), y: round(v.y)) 229 | 230 | 231 | proc sign*(v: Vector2): Vector2 = 232 | Vector2(x: sign(v.x), y: sign(v.y)) 233 | 234 | 235 | proc rotated*(v: Vector2, angle: float): Vector2 = 236 | let 237 | s = sin(angle) 238 | c = cos(angle) 239 | Vector2( 240 | x: v.x * c - v.y * s, 241 | y: v.x * s + v.y + c 242 | ) 243 | 244 | 245 | proc directionTo*(vFrom, vTo: Vector2): Vector2 {.inline.} = 246 | result = (vTo - vFrom).normalized() 247 | 248 | 249 | proc posmod*(vec: Vector2, pmod: float): Vector2 = 250 | Vector2(x: fposmod(vec.x, pmod), y: fposmod(vec.y, pmod)) 251 | 252 | 253 | proc posmodv*(vec, pmod: Vector2): Vector2 = 254 | Vector2(x: fposmod(vec.x, pmod.x), y: fposmod(vec.y, pmod.y)) 255 | 256 | 257 | proc project*(vFrom, vTo: Vector2): Vector2 = 258 | vTo * (dot(vFrom, vTo) / vTo.lengthSquared()) 259 | 260 | 261 | proc clamp*(v, min, max: Vector2): Vector2 = 262 | Vector2( 263 | x: clamp(v.x, min.x, max.x), 264 | y: clamp(v.y, min.y, max.y) 265 | ) 266 | 267 | 268 | proc planeProject*(vec: Vector2; pD: float, pVec: Vector2): Vector2 = 269 | result = pVec - vec * (dot(vec, pVec) - pD) 270 | 271 | 272 | proc lerp*(vFrom, vTo: Vector2, weight: float): Vector2 {.inline.} = 273 | result = vFrom + weight * (vTo - vFrom) 274 | 275 | 276 | proc slerp*(vFrom, vTo: Vector2, weight: float): Vector2 {.inline.} = 277 | let 278 | startLengthSq = vFrom.lengthSquared() 279 | endLengthSq = vTo.lengthSquared() 280 | if unlikely(startLengthSq == 0.0 or endLengthSq == 0.0): 281 | return lerp(vFrom, vTo, weight) 282 | let 283 | startLength = sqrt(startLengthSq) 284 | resultLength = lerp(startLength, sqrt(endLengthSq), weight) 285 | angle = vFrom.angleTo(vTo) 286 | result = vFrom.rotated(angle * weight) * (resultLength / startLength) 287 | 288 | 289 | proc cubicInterpolate*(a, b, preA, postB: Vector2, 290 | weight: float): Vector2 {.inline.} = 291 | result = a 292 | result.x = cubicInterpolate(result.x, b.x, preA.x, postB.x, weight) 293 | result.y = cubicInterpolate(result.y, b.y, preA.y, postB.y, weight) 294 | 295 | 296 | proc bezierInterpolate*(vstart, ctrl1, ctrl2, vend: Vector2, 297 | t: float): Vector2 {.inline.} = 298 | let 299 | omt = 1 - t 300 | omt2 = omt^2 301 | omt3 = omt2 * omt 302 | t2 = t^2 303 | t3 = t2 * t 304 | result = (vstart * omt3) + (ctrl1 * omt2 * t * 3.0 + ctrl2 * omt * t2 * 3.0) + 305 | (vend * t3) 306 | 307 | 308 | proc moveToward*(vFrom, vTo: Vector2, delta: float): Vector2 = 309 | result = vFrom 310 | let vd = vTo - result 311 | let len = vd.length() 312 | result = if len <= delta or len < CMP_EPSILON: vTo else: result + vd / len * delta 313 | 314 | 315 | proc slide*(v, normal: Vector2): Vector2 = 316 | result = v - normal * v.dot(normal) 317 | 318 | 319 | proc reflect*(v, normal: Vector2): Vector2 = 320 | result = 2 * normal * v.dot(normal) - v 321 | 322 | 323 | proc bounce*(v, normal: Vector2): Vector2 = -v.reflect(normal) 324 | 325 | 326 | proc isEqualApprox*(v1, v2: Vector2): bool = 327 | result = isEqualApprox(v1.x, v2.x) and isEqualApprox(v1.y, v2.y) 328 | 329 | 330 | proc orthogonal*(v: Vector2): Vector2 = 331 | Vector2(x: v.y, y: -v.x) 332 | 333 | 334 | proc snapped*(v, by: Vector2): Vector2 = 335 | Vector2( 336 | x: snapped(v.x, by.x), 337 | y: snapped(v.x, by.y) 338 | ) 339 | 340 | 341 | proc aspect*(v: Vector2): float = v.x / v.y 342 | 343 | 344 | proc fromAngle*(angle: float): Vector2 = 345 | Vector2(x: cos(angle), y: sin(angle)) 346 | 347 | 348 | proc toString*(v: Vector2): string = 349 | result = "[" & $v.x & ", " & $v.y & "]" 350 | 351 | 352 | proc `$`*(v: Vector2): string = v.toString() 353 | -------------------------------------------------------------------------------- /src/gdextension_nim/core/global_constants.nim: -------------------------------------------------------------------------------- 1 | ## *********************************************************************** 2 | ## global_constants.hpp 3 | ## *********************************************************************** 4 | ## This file is part of: 5 | ## GODOT ENGINE 6 | ## https://godotengine.org 7 | ## *********************************************************************** 8 | ## Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. 9 | ## Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). 10 | ## 11 | ## Permission is hereby granted, free of charge, to any person obtaining 12 | ## a copy of this software and associated documentation files (the 13 | ## "Software"), to deal in the Software without restriction, including 14 | ## without limitation the rights to use, copy, modify, merge, publish, 15 | ## distribute, sublicense, and/or sell copies of the Software, and to 16 | ## permit persons to whom the Software is furnished to do so, subject to 17 | ## the following conditions: 18 | ## 19 | ## The above copyright notice and this permission notice shall be 20 | ## included in all copies or substantial portions of the Software. 21 | ## 22 | ## THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 23 | ## EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 24 | ## MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 25 | ## IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 26 | ## CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 27 | ## TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 28 | ## SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 29 | ## *********************************************************************** 30 | ## THIS FILE IS GENERATED. EDITS WILL BE LOST. 31 | 32 | type 33 | Side* = enum 34 | SIDE_LEFT = 0, SIDE_TOP = 1, SIDE_RIGHT = 2, SIDE_BOTTOM = 3 35 | 36 | 37 | type 38 | Corner* = enum 39 | CORNER_TOP_LEFT = 0, CORNER_TOP_RIGHT = 1, CORNER_BOTTOM_RIGHT = 2, 40 | CORNER_BOTTOM_LEFT = 3 41 | 42 | 43 | type 44 | Orientation* = enum 45 | HORIZONTAL = 0, VERTICAL = 1 46 | 47 | 48 | type 49 | ClockDirection* = enum 50 | CLOCKWISE = 0, COUNTERCLOCKWISE = 1 51 | 52 | 53 | type 54 | HorizontalAlignment* = enum 55 | HORIZONTAL_ALIGNMENT_LEFT = 0, HORIZONTAL_ALIGNMENT_CENTER = 1, 56 | HORIZONTAL_ALIGNMENT_RIGHT = 2, HORIZONTAL_ALIGNMENT_FILL = 3 57 | 58 | 59 | type 60 | VerticalAlignment* = enum 61 | VERTICAL_ALIGNMENT_TOP = 0, VERTICAL_ALIGNMENT_CENTER = 1, 62 | VERTICAL_ALIGNMENT_BOTTOM = 2, VERTICAL_ALIGNMENT_FILL = 3 63 | 64 | 65 | type 66 | InlineAlignment* = enum 67 | INLINE_ALIGNMENT_TOP_TO = 0, INLINE_ALIGNMENT_CENTER_TO = 1, 68 | INLINE_ALIGNMENT_BOTTOM_TO = 2, INLINE_ALIGNMENT_IMAGE_MASK = 3, 69 | INLINE_ALIGNMENT_TO_CENTER = 4, INLINE_ALIGNMENT_CENTER = 5, 70 | INLINE_ALIGNMENT_TO_BASELINE = 8, INLINE_ALIGNMENT_TO_BOTTOM = 12, 71 | INLINE_ALIGNMENT_BOTTOM = 14 72 | 73 | const 74 | INLINE_ALIGNMENT_TO_TOP* = INLINE_ALIGNMENT_TOP_TO 75 | INLINE_ALIGNMENT_TOP* = INLINE_ALIGNMENT_TOP_TO 76 | INLINE_ALIGNMENT_TEXT_MASK* = INLINE_ALIGNMENT_TO_BOTTOM 77 | 78 | type 79 | Key* = enum 80 | KEY_NONE = 0, KEY_SPACE = 32, KEY_EXCLAM = 33, KEY_QUOTEDBL = 34, 81 | KEY_NUMBERSIGN = 35, 82 | KEY_DOLLAR = 36, KEY_PERCENT = 37, KEY_AMPERSAND = 38, KEY_APOSTROPHE = 39, 83 | KEY_PARENLEFT = 40, KEY_PARENRIGHT = 41, KEY_ASTERISK = 42, KEY_PLUS = 43, 84 | KEY_COMMA = 44, KEY_MINUS = 45, KEY_PERIOD = 46, KEY_SLASH = 47, KEY_0 = 48, 85 | KEY_1 = 49, 86 | KEY_2 = 50, KEY_3 = 51, KEY_4 = 52, KEY_5 = 53, KEY_6 = 54, KEY_7 = 55, 87 | KEY_8 = 56, KEY_9 = 57, 88 | KEY_COLON = 58, KEY_SEMICOLON = 59, KEY_LESS = 60, KEY_EQUAL = 61, 89 | KEY_GREATER = 62, 90 | KEY_QUESTION = 63, KEY_AT = 64, KEY_A = 65, KEY_B = 66, KEY_C = 67, 91 | KEY_D = 68, KEY_E = 69, 92 | KEY_F = 70, KEY_G = 71, KEY_H = 72, KEY_I = 73, KEY_J = 74, KEY_K = 75, 93 | KEY_L = 76, KEY_M = 77, 94 | KEY_N = 78, KEY_O = 79, KEY_P = 80, KEY_Q = 81, KEY_R = 82, KEY_S = 83, 95 | KEY_T = 84, KEY_U = 85, 96 | KEY_V = 86, KEY_W = 87, KEY_X = 88, KEY_Y = 89, KEY_Z = 90, 97 | KEY_BRACKETLEFT = 91, 98 | KEY_BACKSLASH = 92, KEY_BRACKETRIGHT = 93, KEY_ASCIICIRCUM = 94, 99 | KEY_UNDERSCORE = 95, 100 | KEY_QUOTELEFT = 96, KEY_BRACELEFT = 123, KEY_BAR = 124, 101 | KEY_BRACERIGHT = 125, 102 | KEY_ASCIITILDE = 126, KEY_NOBREAKSPACE = 160, KEY_EXCLAMDOWN = 161, 103 | KEY_CENT = 162, 104 | KEY_STERLING = 163, KEY_CURRENCY = 164, KEY_YEN = 165, KEY_BROKENBAR = 166, 105 | KEY_SECTION = 167, KEY_DIAERESIS = 168, KEY_COPYRIGHT = 169, 106 | KEY_ORDFEMININE = 170, 107 | KEY_GUILLEMOTLEFT = 171, KEY_NOTSIGN = 172, KEY_HYPHEN = 173, 108 | KEY_REGISTERED = 174, 109 | KEY_MACRON = 175, KEY_DEGREE = 176, KEY_PLUSMINUS = 177, 110 | KEY_TWOSUPERIOR = 178, 111 | KEY_THREESUPERIOR = 179, KEY_ACUTE = 180, KEY_MU = 181, KEY_PARAGRAPH = 182, 112 | KEY_PERIODCENTERED = 183, KEY_CEDILLA = 184, KEY_ONESUPERIOR = 185, 113 | KEY_MASCULINE = 186, KEY_GUILLEMOTRIGHT = 187, KEY_ONEQUARTER = 188, 114 | KEY_ONEHALF = 189, KEY_THREEQUARTERS = 190, KEY_QUESTIONDOWN = 191, 115 | KEY_AGRAVE = 192, 116 | KEY_AACUTE = 193, KEY_ACIRCUMFLEX = 194, KEY_ATILDE = 195, 117 | KEY_ADIAERESIS = 196, 118 | KEY_ARING = 197, KEY_AE = 198, KEY_CCEDILLA = 199, KEY_EGRAVE = 200, 119 | KEY_EACUTE = 201, 120 | KEY_ECIRCUMFLEX = 202, KEY_EDIAERESIS = 203, KEY_IGRAVE = 204, 121 | KEY_IACUTE = 205, 122 | KEY_ICIRCUMFLEX = 206, KEY_IDIAERESIS = 207, KEY_ETH = 208, 123 | KEY_NTILDE = 209, 124 | KEY_OGRAVE = 210, KEY_OACUTE = 211, KEY_OCIRCUMFLEX = 212, KEY_OTILDE = 213, 125 | KEY_ODIAERESIS = 214, KEY_MULTIPLY = 215, KEY_OOBLIQUE = 216, 126 | KEY_UGRAVE = 217, 127 | KEY_UACUTE = 218, KEY_UCIRCUMFLEX = 219, KEY_UDIAERESIS = 220, 128 | KEY_YACUTE = 221, 129 | KEY_THORN = 222, KEY_SSHARP = 223, KEY_DIVISION = 247, KEY_YDIAERESIS = 255, 130 | KEY_SPECIAL = 16777216, KEY_ESCAPE = 16777217, KEY_TAB = 16777218, 131 | KEY_BACKTAB = 16777219, KEY_BACKSPACE = 16777220, KEY_ENTER = 16777221, 132 | KEY_KP_ENTER = 16777222, KEY_INSERT = 16777223, KEY_DELETE = 16777224, 133 | KEY_PAUSE = 16777225, KEY_PRINT = 16777226, KEY_SYSREQ = 16777227, 134 | KEY_CLEAR = 16777228, KEY_HOME = 16777229, KEY_END = 16777230, 135 | KEY_LEFT = 16777231, 136 | KEY_UP = 16777232, KEY_RIGHT = 16777233, KEY_DOWN = 16777234, 137 | KEY_PAGEUP = 16777235, 138 | KEY_PAGEDOWN = 16777236, KEY_SHIFT = 16777237, KEY_CTRL = 16777238, 139 | KEY_META = 16777239, KEY_ALT = 16777240, KEY_CAPSLOCK = 16777241, 140 | KEY_NUMLOCK = 16777242, KEY_SCROLLLOCK = 16777243, KEY_F1 = 16777244, 141 | KEY_F2 = 16777245, KEY_F3 = 16777246, KEY_F4 = 16777247, KEY_F5 = 16777248, 142 | KEY_F6 = 16777249, KEY_F7 = 16777250, KEY_F8 = 16777251, KEY_F9 = 16777252, 143 | KEY_F10 = 16777253, KEY_F11 = 16777254, KEY_F12 = 16777255, 144 | KEY_F13 = 16777256, 145 | KEY_F14 = 16777257, KEY_F15 = 16777258, KEY_F16 = 16777259, 146 | KEY_F17 = 16777260, 147 | KEY_F18 = 16777261, KEY_F19 = 16777262, KEY_F20 = 16777263, 148 | KEY_F21 = 16777264, 149 | KEY_F22 = 16777265, KEY_F23 = 16777266, KEY_F24 = 16777267, 150 | KEY_F25 = 16777268, 151 | KEY_F26 = 16777269, KEY_F27 = 16777270, KEY_F28 = 16777271, 152 | KEY_F29 = 16777272, 153 | KEY_F30 = 16777273, KEY_F31 = 16777274, KEY_F32 = 16777275, 154 | KEY_F33 = 16777276, 155 | KEY_F34 = 16777277, KEY_F35 = 16777278, KEY_SUPER_L = 16777280, 156 | KEY_SUPER_R = 16777281, KEY_MENU = 16777282, KEY_HYPER_L = 16777283, 157 | KEY_HYPER_R = 16777284, KEY_HELP = 16777285, KEY_DIRECTION_L = 16777286, 158 | KEY_DIRECTION_R = 16777287, KEY_BACK = 16777288, KEY_FORWARD = 16777289, 159 | KEY_STOP = 16777290, KEY_REFRESH = 16777291, KEY_VOLUMEDOWN = 16777292, 160 | KEY_VOLUMEMUTE = 16777293, KEY_VOLUMEUP = 16777294, 161 | KEY_BASSBOOST = 16777295, 162 | KEY_BASSUP = 16777296, KEY_BASSDOWN = 16777297, KEY_TREBLEUP = 16777298, 163 | KEY_TREBLEDOWN = 16777299, KEY_MEDIAPLAY = 16777300, 164 | KEY_MEDIASTOP = 16777301, 165 | KEY_MEDIAPREVIOUS = 16777302, KEY_MEDIANEXT = 16777303, 166 | KEY_MEDIARECORD = 16777304, KEY_HOMEPAGE = 16777305, 167 | KEY_FAVORITES = 16777306, 168 | KEY_SEARCH = 16777307, KEY_STANDBY = 16777308, KEY_OPENURL = 16777309, 169 | KEY_LAUNCHMAIL = 16777310, KEY_LAUNCHMEDIA = 16777311, 170 | KEY_LAUNCH0 = 16777312, 171 | KEY_LAUNCH1 = 16777313, KEY_LAUNCH2 = 16777314, KEY_LAUNCH3 = 16777315, 172 | KEY_LAUNCH4 = 16777316, KEY_LAUNCH5 = 16777317, KEY_LAUNCH6 = 16777318, 173 | KEY_LAUNCH7 = 16777319, KEY_LAUNCH8 = 16777320, KEY_LAUNCH9 = 16777321, 174 | KEY_LAUNCHA = 16777322, KEY_LAUNCHB = 16777323, KEY_LAUNCHC = 16777324, 175 | KEY_LAUNCHD = 16777325, KEY_LAUNCHE = 16777326, KEY_LAUNCHF = 16777327, 176 | KEY_KP_MULTIPLY = 16777345, KEY_KP_DIVIDE = 16777346, 177 | KEY_KP_SUBTRACT = 16777347, 178 | KEY_KP_PERIOD = 16777348, KEY_KP_ADD = 16777349, KEY_KP_0 = 16777350, 179 | KEY_KP_1 = 16777351, KEY_KP_2 = 16777352, KEY_KP_3 = 16777353, 180 | KEY_KP_4 = 16777354, 181 | KEY_KP_5 = 16777355, KEY_KP_6 = 16777356, KEY_KP_7 = 16777357, 182 | KEY_KP_8 = 16777358, 183 | KEY_KP_9 = 16777359, KEY_UNKNOWN = 33554431 184 | 185 | 186 | type 187 | KeyModifierMasks* = enum 188 | KEY_CODE_MASK = 33554431, 189 | KEY_MASK_SHIFT = 33554432, 190 | KEY_MASK_ALT = 67108864, 191 | KEY_MASK_META = 134217728, 192 | KEY_MASK_CTRL = 268435456, 193 | KEY_MASK_KPAD = 536870912, 194 | KEY_MASK_GROUP_SWITCH = 1073741824, 195 | KEY_MODIFIER_MASK = 2130706432 196 | 197 | const 198 | KEY_MASK_CMD* = KEY_MASK_CTRL 199 | 200 | type 201 | MouseButton* = enum 202 | MOUSE_BUTTON_NONE = 0, MOUSE_BUTTON_LEFT = 1, MOUSE_BUTTON_RIGHT = 2, 203 | MOUSE_BUTTON_MIDDLE = 3, MOUSE_BUTTON_WHEEL_UP = 4, 204 | MOUSE_BUTTON_WHEEL_DOWN = 5, 205 | MOUSE_BUTTON_WHEEL_LEFT = 6, MOUSE_BUTTON_WHEEL_RIGHT = 7, 206 | MOUSE_BUTTON_XBUTTON1 = 8, MOUSE_BUTTON_XBUTTON2 = 9, 207 | MOUSE_BUTTON_MASK_XBUTTON1 = 128, MOUSE_BUTTON_MASK_XBUTTON2 = 256 208 | 209 | const 210 | MOUSE_BUTTON_MASK_LEFT* = MOUSE_BUTTON_LEFT 211 | MOUSE_BUTTON_MASK_RIGHT* = MOUSE_BUTTON_RIGHT 212 | MOUSE_BUTTON_MASK_MIDDLE* = MOUSE_BUTTON_WHEEL_UP 213 | 214 | type 215 | JoyButton* = enum 216 | JOY_BUTTON_INVALID = -1, JOY_BUTTON_A = 0, JOY_BUTTON_B = 1, 217 | JOY_BUTTON_X = 2, 218 | JOY_BUTTON_Y = 3, JOY_BUTTON_BACK = 4, JOY_BUTTON_GUIDE = 5, 219 | JOY_BUTTON_START = 6, 220 | JOY_BUTTON_LEFT_STICK = 7, JOY_BUTTON_RIGHT_STICK = 8, 221 | JOY_BUTTON_LEFT_SHOULDER = 9, JOY_BUTTON_RIGHT_SHOULDER = 10, 222 | JOY_BUTTON_DPAD_UP = 11, JOY_BUTTON_DPAD_DOWN = 12, 223 | JOY_BUTTON_DPAD_LEFT = 13, 224 | JOY_BUTTON_DPAD_RIGHT = 14, JOY_BUTTON_MISC1 = 15, JOY_BUTTON_PADDLE1 = 16, 225 | JOY_BUTTON_PADDLE2 = 17, JOY_BUTTON_PADDLE3 = 18, JOY_BUTTON_PADDLE4 = 19, 226 | JOY_BUTTON_TOUCHPAD = 20, JOY_BUTTON_SDL_MAX = 21, JOY_BUTTON_MAX = 128 227 | 228 | 229 | type 230 | JoyAxis* = enum 231 | JOY_AXIS_INVALID = -1, JOY_AXIS_LEFT_X = 0, JOY_AXIS_LEFT_Y = 1, 232 | JOY_AXIS_RIGHT_X = 2, JOY_AXIS_RIGHT_Y = 3, JOY_AXIS_TRIGGER_LEFT = 4, 233 | JOY_AXIS_TRIGGER_RIGHT = 5, JOY_AXIS_SDL_MAX = 6, JOY_AXIS_MAX = 10 234 | 235 | 236 | type 237 | MIDIMessage* = enum 238 | MIDI_MESSAGE_NONE = 0, MIDI_MESSAGE_NOTE_OFF = 8, MIDI_MESSAGE_NOTE_ON = 9, 239 | MIDI_MESSAGE_AFTERTOUCH = 10, MIDI_MESSAGE_CONTROL_CHANGE = 11, 240 | MIDI_MESSAGE_PROGRAM_CHANGE = 12, MIDI_MESSAGE_CHANNEL_PRESSURE = 13, 241 | MIDI_MESSAGE_PITCH_BEND = 14, MIDI_MESSAGE_SYSTEM_EXCLUSIVE = 240, 242 | MIDI_MESSAGE_QUARTER_FRAME = 241, MIDI_MESSAGE_SONG_POSITION_POINTER = 242, 243 | MIDI_MESSAGE_SONG_SELECT = 243, MIDI_MESSAGE_TUNE_REQUEST = 246, 244 | MIDI_MESSAGE_TIMING_CLOCK = 248, MIDI_MESSAGE_START = 250, 245 | MIDI_MESSAGE_CONTINUE = 251, MIDI_MESSAGE_STOP = 252, 246 | MIDI_MESSAGE_ACTIVE_SENSING = 254, MIDI_MESSAGE_SYSTEM_RESET = 255 247 | 248 | 249 | type 250 | Error* = enum 251 | OK = 0, FAILED = 1, ERR_UNAVAILABLE = 2, ERR_UNCONFIGURED = 3, 252 | ERR_UNAUTHORIZED = 4, 253 | ERR_PARAMETER_RANGE_ERROR = 5, ERR_OUT_OF_MEMORY = 6, 254 | ERR_FILE_NOT_FOUND = 7, 255 | ERR_FILE_BAD_DRIVE = 8, ERR_FILE_BAD_PATH = 9, ERR_FILE_NO_PERMISSION = 10, 256 | ERR_FILE_ALREADY_IN_USE = 11, ERR_FILE_CANT_OPEN = 12, 257 | ERR_FILE_CANT_WRITE = 13, 258 | ERR_FILE_CANT_READ = 14, ERR_FILE_UNRECOGNIZED = 15, ERR_FILE_CORRUPT = 16, 259 | ERR_FILE_MISSING_DEPENDENCIES = 17, ERR_FILE_EOF = 18, ERR_CANT_OPEN = 19, 260 | ERR_CANT_CREATE = 20, ERR_QUERY_FAILED = 21, ERR_ALREADY_IN_USE = 22, 261 | ERR_LOCKED = 23, ERR_TIMEOUT = 24, ERR_CANT_CONNECT = 25, 262 | ERR_CANT_RESOLVE = 26, 263 | ERR_CONNECTION_ERROR = 27, ERR_CANT_ACQUIRE_RESOURCE = 28, 264 | ERR_CANT_FORK = 29, 265 | ERR_INVALID_DATA = 30, ERR_INVALID_PARAMETER = 31, ERR_ALREADY_EXISTS = 32, 266 | ERR_DOES_NOT_EXIST = 33, ERR_DATABASE_CANT_READ = 34, 267 | ERR_DATABASE_CANT_WRITE = 35, ERR_COMPILATION_FAILED = 36, 268 | ERR_METHOD_NOT_FOUND = 37, ERR_LINK_FAILED = 38, ERR_SCRIPT_FAILED = 39, 269 | ERR_CYCLIC_LINK = 40, ERR_INVALID_DECLARATION = 41, 270 | ERR_DUPLICATE_SYMBOL = 42, 271 | ERR_PARSE_ERROR = 43, ERR_BUSY = 44, ERR_SKIP = 45, ERR_HELP = 46, 272 | ERR_BUG = 47, 273 | ERR_PRINTER_ON_FIRE = 48 274 | 275 | 276 | type 277 | PropertyHint* = enum 278 | PROPERTY_HINT_NONE = 0, PROPERTY_HINT_RANGE = 1, PROPERTY_HINT_ENUM = 2, 279 | PROPERTY_HINT_ENUM_SUGGESTION = 3, PROPERTY_HINT_EXP_EASING = 4, 280 | PROPERTY_HINT_LINK = 5, PROPERTY_HINT_FLAGS = 6, 281 | PROPERTY_HINT_LAYERS_2D_RENDER = 7, PROPERTY_HINT_LAYERS_2D_PHYSICS = 8, 282 | PROPERTY_HINT_LAYERS_2D_NAVIGATION = 9, PROPERTY_HINT_LAYERS_3D_RENDER = 10, 283 | PROPERTY_HINT_LAYERS_3D_PHYSICS = 11, 284 | PROPERTY_HINT_LAYERS_3D_NAVIGATION = 12, 285 | PROPERTY_HINT_FILE = 13, PROPERTY_HINT_DIR = 14, 286 | PROPERTY_HINT_GLOBAL_FILE = 15, 287 | PROPERTY_HINT_GLOBAL_DIR = 16, PROPERTY_HINT_RESOURCE_TYPE = 17, 288 | PROPERTY_HINT_MULTILINE_TEXT = 18, PROPERTY_HINT_EXPRESSION = 19, 289 | PROPERTY_HINT_PLACEHOLDER_TEXT = 20, PROPERTY_HINT_COLOR_NO_ALPHA = 21, 290 | PROPERTY_HINT_IMAGE_COMPRESS_LOSSY = 22, 291 | PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS = 23, PROPERTY_HINT_OBJECT_ID = 24, 292 | PROPERTY_HINT_TYPE_STRING = 25, PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE = 26, 293 | PROPERTY_HINT_METHOD_OF_VARIANT_TYPE = 27, 294 | PROPERTY_HINT_METHOD_OF_BASE_TYPE = 28, 295 | PROPERTY_HINT_METHOD_OF_INSTANCE = 29, 296 | PROPERTY_HINT_METHOD_OF_SCRIPT = 30, 297 | PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE = 31, 298 | PROPERTY_HINT_PROPERTY_OF_BASE_TYPE = 32, 299 | PROPERTY_HINT_PROPERTY_OF_INSTANCE = 33, 300 | PROPERTY_HINT_PROPERTY_OF_SCRIPT = 34, 301 | PROPERTY_HINT_OBJECT_TOO_BIG = 35, PROPERTY_HINT_NODE_PATH_VALID_TYPES = 36, 302 | PROPERTY_HINT_SAVE_FILE = 37, PROPERTY_HINT_GLOBAL_SAVE_FILE = 38, 303 | PROPERTY_HINT_INT_IS_OBJECTID = 39, PROPERTY_HINT_ARRAY_TYPE = 40, 304 | PROPERTY_HINT_INT_IS_POINTER = 41, PROPERTY_HINT_LOCALE_ID = 42, 305 | PROPERTY_HINT_LOCALIZABLE_STRING = 43, PROPERTY_HINT_NODE_TYPE = 44, 306 | PROPERTY_HINT_MAX = 45 307 | 308 | 309 | type 310 | PropertyUsageFlags* = enum 311 | PROPERTY_USAGE_NONE = 0, PROPERTY_USAGE_STORAGE = 2, 312 | PROPERTY_USAGE_EDITOR = 4, 313 | PROPERTY_USAGE_DEFAULT = 6, PROPERTY_USAGE_CHECKABLE = 8, 314 | PROPERTY_USAGE_CHECKED = 16, PROPERTY_USAGE_INTERNATIONALIZED = 32, 315 | PROPERTY_USAGE_DEFAULT_INTL = 38, PROPERTY_USAGE_GROUP = 64, 316 | PROPERTY_USAGE_CATEGORY = 128, PROPERTY_USAGE_SUBGROUP = 256, 317 | PROPERTY_USAGE_CLASS_IS_BITFIELD = 512, 318 | PROPERTY_USAGE_NO_INSTANCE_STATE = 1024, 319 | PROPERTY_USAGE_RESTART_IF_CHANGED = 2048, 320 | PROPERTY_USAGE_SCRIPT_VARIABLE = 4096, PROPERTY_USAGE_STORE_IF_NULL = 8192, 321 | PROPERTY_USAGE_ANIMATE_AS_TRIGGER = 16384, 322 | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED = 32768, 323 | PROPERTY_USAGE_SCRIPT_DEFAULT_VALUE = 65536, 324 | PROPERTY_USAGE_CLASS_IS_ENUM = 131072, 325 | PROPERTY_USAGE_NIL_IS_VARIANT = 262144, 326 | PROPERTY_USAGE_INTERNAL = 524288, 327 | PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE = 1048576, 328 | PROPERTY_USAGE_HIGH_END_GFX = 2097152, 329 | PROPERTY_USAGE_NODE_PATH_FROM_SCENE_ROOT = 4194304, 330 | PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT = 8388608, 331 | PROPERTY_USAGE_KEYING_INCREMENTS = 16777216, 332 | PROPERTY_USAGE_DEFERRED_SET_RESOURCE = 33554432, 333 | PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT = 67108864, 334 | PROPERTY_USAGE_EDITOR_BASIC_SETTING = 134217728, 335 | PROPERTY_USAGE_ARRAY = 536870912 336 | 337 | const 338 | PROPERTY_USAGE_NO_EDITOR* = PROPERTY_USAGE_STORAGE 339 | 340 | type 341 | MethodFlags* = enum 342 | METHOD_FLAG_NORMAL = 1, METHOD_FLAG_EDITOR = 2, METHOD_FLAG_CONST = 4, 343 | METHOD_FLAG_VIRTUAL = 8, METHOD_FLAG_VARARG = 16, METHOD_FLAG_STATIC = 32, 344 | METHOD_FLAG_OBJECT_CORE = 64 345 | 346 | const 347 | METHOD_FLAGS_DEFAULT* = METHOD_FLAG_NORMAL 348 | 349 | ## namespace godot 350 | -------------------------------------------------------------------------------- /godot-headers/godot/gdnative_interface.h: -------------------------------------------------------------------------------- 1 | /*************************************************************************/ 2 | /* gdnative_interface.h */ 3 | /*************************************************************************/ 4 | /* This file is part of: */ 5 | /* GODOT ENGINE */ 6 | /* https://godotengine.org */ 7 | /*************************************************************************/ 8 | /* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */ 9 | /* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */ 10 | /* */ 11 | /* Permission is hereby granted, free of charge, to any person obtaining */ 12 | /* a copy of this software and associated documentation files (the */ 13 | /* "Software"), to deal in the Software without restriction, including */ 14 | /* without limitation the rights to use, copy, modify, merge, publish, */ 15 | /* distribute, sublicense, and/or sell copies of the Software, and to */ 16 | /* permit persons to whom the Software is furnished to do so, subject to */ 17 | /* the following conditions: */ 18 | /* */ 19 | /* The above copyright notice and this permission notice shall be */ 20 | /* included in all copies or substantial portions of the Software. */ 21 | /* */ 22 | /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ 23 | /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ 24 | /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ 25 | /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ 26 | /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ 27 | /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ 28 | /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ 29 | /*************************************************************************/ 30 | 31 | #ifdef C2NIM 32 | # cdecl 33 | # mangle ssize_t int 34 | # mangle uint64_t uint64 35 | # mangle uint32_t uint32 36 | # mangle uint16_t uint16 37 | # mangle uint8_t uint8 38 | # mangle int64_t int64 39 | # mangle int32_t int32 40 | # mangle int16_t int16 41 | # mangle int8_t int8 42 | # mangle wchar_t uint32 43 | #endif 44 | 45 | #ifndef GDNATIVE_INTERFACE_H 46 | #define GDNATIVE_INTERFACE_H 47 | 48 | /* This is a C class header, you can copy it and use it directly in your own binders. 49 | * Together with the JSON file, you should be able to generate any binder. 50 | */ 51 | 52 | #include 53 | #include 54 | #include 55 | 56 | #ifndef __cplusplus 57 | typedef uint32_t char32_t; 58 | typedef uint16_t char16_t; 59 | #endif 60 | 61 | #ifdef __cplusplus 62 | extern "C" { 63 | #endif 64 | 65 | /* VARIANT TYPES */ 66 | 67 | typedef enum { 68 | GDNATIVE_VARIANT_TYPE_NIL, 69 | 70 | /* atomic types */ 71 | GDNATIVE_VARIANT_TYPE_BOOL, 72 | GDNATIVE_VARIANT_TYPE_INT, 73 | GDNATIVE_VARIANT_TYPE_FLOAT, 74 | GDNATIVE_VARIANT_TYPE_STRING, 75 | 76 | /* math types */ 77 | GDNATIVE_VARIANT_TYPE_VECTOR2, 78 | GDNATIVE_VARIANT_TYPE_VECTOR2I, 79 | GDNATIVE_VARIANT_TYPE_RECT2, 80 | GDNATIVE_VARIANT_TYPE_RECT2I, 81 | GDNATIVE_VARIANT_TYPE_VECTOR3, 82 | GDNATIVE_VARIANT_TYPE_VECTOR3I, 83 | GDNATIVE_VARIANT_TYPE_TRANSFORM2D, 84 | GDNATIVE_VARIANT_TYPE_VECTOR4, 85 | GDNATIVE_VARIANT_TYPE_VECTOR4I, 86 | GDNATIVE_VARIANT_TYPE_PLANE, 87 | GDNATIVE_VARIANT_TYPE_QUATERNION, 88 | GDNATIVE_VARIANT_TYPE_AABB, 89 | GDNATIVE_VARIANT_TYPE_BASIS, 90 | GDNATIVE_VARIANT_TYPE_TRANSFORM3D, 91 | GDNATIVE_VARIANT_TYPE_PROJECTION, 92 | 93 | /* misc types */ 94 | GDNATIVE_VARIANT_TYPE_COLOR, 95 | GDNATIVE_VARIANT_TYPE_STRING_NAME, 96 | GDNATIVE_VARIANT_TYPE_NODE_PATH, 97 | GDNATIVE_VARIANT_TYPE_RID, 98 | GDNATIVE_VARIANT_TYPE_OBJECT, 99 | GDNATIVE_VARIANT_TYPE_CALLABLE, 100 | GDNATIVE_VARIANT_TYPE_SIGNAL, 101 | GDNATIVE_VARIANT_TYPE_DICTIONARY, 102 | GDNATIVE_VARIANT_TYPE_ARRAY, 103 | 104 | /* typed arrays */ 105 | GDNATIVE_VARIANT_TYPE_PACKED_BYTE_ARRAY, 106 | GDNATIVE_VARIANT_TYPE_PACKED_INT32_ARRAY, 107 | GDNATIVE_VARIANT_TYPE_PACKED_INT64_ARRAY, 108 | GDNATIVE_VARIANT_TYPE_PACKED_FLOAT32_ARRAY, 109 | GDNATIVE_VARIANT_TYPE_PACKED_FLOAT64_ARRAY, 110 | GDNATIVE_VARIANT_TYPE_PACKED_STRING_ARRAY, 111 | GDNATIVE_VARIANT_TYPE_PACKED_VECTOR2_ARRAY, 112 | GDNATIVE_VARIANT_TYPE_PACKED_VECTOR3_ARRAY, 113 | GDNATIVE_VARIANT_TYPE_PACKED_COLOR_ARRAY, 114 | 115 | GDNATIVE_VARIANT_TYPE_VARIANT_MAX 116 | } GDNativeVariantType; 117 | 118 | typedef enum { 119 | /* comparison */ 120 | GDNATIVE_VARIANT_OP_EQUAL, 121 | GDNATIVE_VARIANT_OP_NOT_EQUAL, 122 | GDNATIVE_VARIANT_OP_LESS, 123 | GDNATIVE_VARIANT_OP_LESS_EQUAL, 124 | GDNATIVE_VARIANT_OP_GREATER, 125 | GDNATIVE_VARIANT_OP_GREATER_EQUAL, 126 | /* mathematic */ 127 | GDNATIVE_VARIANT_OP_ADD, 128 | GDNATIVE_VARIANT_OP_SUBTRACT, 129 | GDNATIVE_VARIANT_OP_MULTIPLY, 130 | GDNATIVE_VARIANT_OP_DIVIDE, 131 | GDNATIVE_VARIANT_OP_NEGATE, 132 | GDNATIVE_VARIANT_OP_POSITIVE, 133 | GDNATIVE_VARIANT_OP_MODULE, 134 | GDNATIVE_VARIANT_OP_POWER, 135 | /* bitwise */ 136 | GDNATIVE_VARIANT_OP_SHIFT_LEFT, 137 | GDNATIVE_VARIANT_OP_SHIFT_RIGHT, 138 | GDNATIVE_VARIANT_OP_BIT_AND, 139 | GDNATIVE_VARIANT_OP_BIT_OR, 140 | GDNATIVE_VARIANT_OP_BIT_XOR, 141 | GDNATIVE_VARIANT_OP_BIT_NEGATE, 142 | /* logic */ 143 | GDNATIVE_VARIANT_OP_AND, 144 | GDNATIVE_VARIANT_OP_OR, 145 | GDNATIVE_VARIANT_OP_XOR, 146 | GDNATIVE_VARIANT_OP_NOT, 147 | /* containment */ 148 | GDNATIVE_VARIANT_OP_IN, 149 | GDNATIVE_VARIANT_OP_MAX 150 | 151 | } GDNativeVariantOperator; 152 | 153 | typedef void *GDNativeVariantPtr; 154 | typedef void *GDNativeStringNamePtr; 155 | typedef void *GDNativeStringPtr; 156 | typedef void *GDNativeObjectPtr; 157 | typedef void *GDNativeTypePtr; 158 | typedef void *GDNativeExtensionPtr; 159 | typedef void *GDNativeMethodBindPtr; 160 | typedef int64_t GDNativeInt; 161 | typedef uint8_t GDNativeBool; 162 | typedef uint64_t GDObjectInstanceID; 163 | 164 | /* VARIANT DATA I/O */ 165 | 166 | typedef enum { 167 | GDNATIVE_CALL_OK, 168 | GDNATIVE_CALL_ERROR_INVALID_METHOD, 169 | GDNATIVE_CALL_ERROR_INVALID_ARGUMENT, /* expected is variant type */ 170 | GDNATIVE_CALL_ERROR_TOO_MANY_ARGUMENTS, /* expected is number of arguments */ 171 | GDNATIVE_CALL_ERROR_TOO_FEW_ARGUMENTS, /* expected is number of arguments */ 172 | GDNATIVE_CALL_ERROR_INSTANCE_IS_NULL, 173 | GDNATIVE_CALL_ERROR_METHOD_NOT_CONST, /* used for const call */ 174 | } GDNativeCallErrorType; 175 | 176 | typedef struct { 177 | GDNativeCallErrorType error; 178 | int32_t argument; 179 | int32_t expected; 180 | } GDNativeCallError; 181 | 182 | typedef void (*GDNativeVariantFromTypeConstructorFunc)(GDNativeVariantPtr, GDNativeTypePtr); 183 | typedef void (*GDNativeTypeFromVariantConstructorFunc)(GDNativeTypePtr, GDNativeVariantPtr); 184 | typedef void (*GDNativePtrOperatorEvaluator)(const GDNativeTypePtr p_left, const GDNativeTypePtr p_right, GDNativeTypePtr r_result); 185 | typedef void (*GDNativePtrBuiltInMethod)(GDNativeTypePtr p_base, const GDNativeTypePtr *p_args, GDNativeTypePtr r_return, int p_argument_count); 186 | typedef void (*GDNativePtrConstructor)(GDNativeTypePtr p_base, const GDNativeTypePtr *p_args); 187 | typedef void (*GDNativePtrDestructor)(GDNativeTypePtr p_base); 188 | typedef void (*GDNativePtrSetter)(GDNativeTypePtr p_base, const GDNativeTypePtr p_value); 189 | typedef void (*GDNativePtrGetter)(const GDNativeTypePtr p_base, GDNativeTypePtr r_value); 190 | typedef void (*GDNativePtrIndexedSetter)(GDNativeTypePtr p_base, GDNativeInt p_index, const GDNativeTypePtr p_value); 191 | typedef void (*GDNativePtrIndexedGetter)(const GDNativeTypePtr p_base, GDNativeInt p_index, GDNativeTypePtr r_value); 192 | typedef void (*GDNativePtrKeyedSetter)(GDNativeTypePtr p_base, const GDNativeTypePtr p_key, const GDNativeTypePtr p_value); 193 | typedef void (*GDNativePtrKeyedGetter)(const GDNativeTypePtr p_base, const GDNativeTypePtr p_key, GDNativeTypePtr r_value); 194 | typedef uint32_t (*GDNativePtrKeyedChecker)(const GDNativeVariantPtr p_base, const GDNativeVariantPtr p_key); 195 | typedef void (*GDNativePtrUtilityFunction)(GDNativeTypePtr r_return, const GDNativeTypePtr *p_arguments, int p_argument_count); 196 | 197 | typedef GDNativeObjectPtr (*GDNativeClassConstructor)(); 198 | 199 | typedef void *(*GDNativeInstanceBindingCreateCallback)(void *p_token, void *p_instance); 200 | typedef void (*GDNativeInstanceBindingFreeCallback)(void *p_token, void *p_instance, void *p_binding); 201 | typedef GDNativeBool (*GDNativeInstanceBindingReferenceCallback)(void *p_token, void *p_binding, GDNativeBool p_reference); 202 | 203 | typedef struct { 204 | GDNativeInstanceBindingCreateCallback create_callback; 205 | GDNativeInstanceBindingFreeCallback free_callback; 206 | GDNativeInstanceBindingReferenceCallback reference_callback; 207 | } GDNativeInstanceBindingCallbacks; 208 | 209 | /* EXTENSION CLASSES */ 210 | 211 | typedef void *GDExtensionClassInstancePtr; 212 | 213 | typedef GDNativeBool (*GDNativeExtensionClassSet)(GDExtensionClassInstancePtr p_instance, const GDNativeStringNamePtr p_name, const GDNativeVariantPtr p_value); 214 | typedef GDNativeBool (*GDNativeExtensionClassGet)(GDExtensionClassInstancePtr p_instance, const GDNativeStringNamePtr p_name, GDNativeVariantPtr r_ret); 215 | typedef uint64_t (*GDNativeExtensionClassGetRID)(GDExtensionClassInstancePtr p_instance); 216 | 217 | typedef struct { 218 | uint32_t type; 219 | const char *name; 220 | const char *class_name; 221 | uint32_t hint; 222 | const char *hint_string; 223 | uint32_t usage; 224 | } GDNativePropertyInfo; 225 | 226 | typedef struct { 227 | const char *name; 228 | GDNativePropertyInfo return_value; 229 | uint32_t flags; // From GDNativeExtensionClassMethodFlags 230 | int32_t id; 231 | GDNativePropertyInfo *arguments; 232 | uint32_t argument_count; 233 | GDNativeVariantPtr default_arguments; 234 | uint32_t default_argument_count; 235 | } GDNativeMethodInfo; 236 | 237 | typedef const GDNativePropertyInfo *(*GDNativeExtensionClassGetPropertyList)(GDExtensionClassInstancePtr p_instance, uint32_t *r_count); 238 | typedef void (*GDNativeExtensionClassFreePropertyList)(GDExtensionClassInstancePtr p_instance, const GDNativePropertyInfo *p_list); 239 | typedef GDNativeBool (*GDNativeExtensionClassPropertyCanRevert)(GDExtensionClassInstancePtr p_instance, const GDNativeStringNamePtr p_name); 240 | typedef GDNativeBool (*GDNativeExtensionClassPropertyGetRevert)(GDExtensionClassInstancePtr p_instance, const GDNativeStringNamePtr p_name, GDNativeVariantPtr r_ret); 241 | typedef void (*GDNativeExtensionClassNotification)(GDExtensionClassInstancePtr p_instance, int32_t p_what); 242 | typedef void (*GDNativeExtensionClassToString)(GDExtensionClassInstancePtr p_instance, GDNativeStringPtr p_out); 243 | typedef void (*GDNativeExtensionClassReference)(GDExtensionClassInstancePtr p_instance); 244 | typedef void (*GDNativeExtensionClassUnreference)(GDExtensionClassInstancePtr p_instance); 245 | typedef void (*GDNativeExtensionClassCallVirtual)(GDExtensionClassInstancePtr p_instance, const GDNativeTypePtr *p_args, GDNativeTypePtr r_ret); 246 | typedef GDNativeObjectPtr (*GDNativeExtensionClassCreateInstance)(void *p_userdata); 247 | typedef void (*GDNativeExtensionClassFreeInstance)(void *p_userdata, GDExtensionClassInstancePtr p_instance); 248 | typedef void (*GDNativeExtensionClassObjectInstance)(GDExtensionClassInstancePtr p_instance, GDNativeObjectPtr p_object_instance); 249 | typedef GDNativeExtensionClassCallVirtual (*GDNativeExtensionClassGetVirtual)(void *p_userdata, const char *p_name); 250 | 251 | typedef struct { 252 | GDNativeExtensionClassSet set_func; 253 | GDNativeExtensionClassGet get_func; 254 | GDNativeExtensionClassGetPropertyList get_property_list_func; 255 | GDNativeExtensionClassFreePropertyList free_property_list_func; 256 | GDNativeExtensionClassPropertyCanRevert property_can_revert_func; 257 | GDNativeExtensionClassPropertyGetRevert property_get_revert_func; 258 | GDNativeExtensionClassNotification notification_func; 259 | GDNativeExtensionClassToString to_string_func; 260 | GDNativeExtensionClassReference reference_func; 261 | GDNativeExtensionClassUnreference unreference_func; 262 | GDNativeExtensionClassCreateInstance create_instance_func; /* this one is mandatory */ 263 | GDNativeExtensionClassFreeInstance free_instance_func; /* this one is mandatory */ 264 | GDNativeExtensionClassGetVirtual get_virtual_func; 265 | GDNativeExtensionClassGetRID get_rid_func; 266 | void *class_userdata; 267 | } GDNativeExtensionClassCreationInfo; 268 | 269 | typedef void *GDNativeExtensionClassLibraryPtr; 270 | 271 | /* Method */ 272 | 273 | typedef enum { 274 | GDNATIVE_EXTENSION_METHOD_FLAG_NORMAL = 1, 275 | GDNATIVE_EXTENSION_METHOD_FLAG_EDITOR = 2, 276 | GDNATIVE_EXTENSION_METHOD_FLAG_CONST = 4, 277 | GDNATIVE_EXTENSION_METHOD_FLAG_VIRTUAL = 8, 278 | GDNATIVE_EXTENSION_METHOD_FLAG_VARARG = 16, 279 | GDNATIVE_EXTENSION_METHOD_FLAG_STATIC = 32, 280 | GDNATIVE_EXTENSION_METHOD_FLAGS_DEFAULT = GDNATIVE_EXTENSION_METHOD_FLAG_NORMAL, 281 | } GDNativeExtensionClassMethodFlags; 282 | 283 | typedef enum { 284 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_NONE, 285 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_INT8, 286 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_INT16, 287 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_INT32, 288 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_INT64, 289 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_UINT8, 290 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_UINT16, 291 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_UINT32, 292 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_UINT64, 293 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_REAL_IS_FLOAT, 294 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_REAL_IS_DOUBLE 295 | } GDNativeExtensionClassMethodArgumentMetadata; 296 | 297 | typedef void (*GDNativeExtensionClassMethodCall)(void *method_userdata, GDExtensionClassInstancePtr p_instance, const GDNativeVariantPtr *p_args, const GDNativeInt p_argument_count, GDNativeVariantPtr r_return, GDNativeCallError *r_error); 298 | typedef void (*GDNativeExtensionClassMethodPtrCall)(void *method_userdata, GDExtensionClassInstancePtr p_instance, const GDNativeTypePtr *p_args, GDNativeTypePtr r_ret); 299 | 300 | /* passing -1 as argument in the following functions refers to the return type */ 301 | typedef GDNativeVariantType (*GDNativeExtensionClassMethodGetArgumentType)(void *p_method_userdata, int32_t p_argument); 302 | typedef void (*GDNativeExtensionClassMethodGetArgumentInfo)(void *p_method_userdata, int32_t p_argument, GDNativePropertyInfo *r_info); 303 | typedef GDNativeExtensionClassMethodArgumentMetadata (*GDNativeExtensionClassMethodGetArgumentMetadata)(void *p_method_userdata, int32_t p_argument); 304 | 305 | typedef struct { 306 | const char *name; 307 | void *method_userdata; 308 | GDNativeExtensionClassMethodCall call_func; 309 | GDNativeExtensionClassMethodPtrCall ptrcall_func; 310 | uint32_t method_flags; /* GDNativeExtensionClassMethodFlags */ 311 | uint32_t argument_count; 312 | GDNativeBool has_return_value; 313 | GDNativeExtensionClassMethodGetArgumentType get_argument_type_func; 314 | GDNativeExtensionClassMethodGetArgumentInfo get_argument_info_func; /* name and hint information for the argument can be omitted in release builds. Class name should always be present if it applies. */ 315 | GDNativeExtensionClassMethodGetArgumentMetadata get_argument_metadata_func; 316 | uint32_t default_argument_count; 317 | GDNativeVariantPtr *default_arguments; 318 | } GDNativeExtensionClassMethodInfo; 319 | 320 | /* SCRIPT INSTANCE EXTENSION */ 321 | 322 | typedef void *GDNativeExtensionScriptInstanceDataPtr; // Pointer to custom ScriptInstance native implementation 323 | 324 | typedef GDNativeBool (*GDNativeExtensionScriptInstanceSet)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeStringNamePtr p_name, const GDNativeVariantPtr p_value); 325 | typedef GDNativeBool (*GDNativeExtensionScriptInstanceGet)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeStringNamePtr p_name, GDNativeVariantPtr r_ret); 326 | typedef const GDNativePropertyInfo *(*GDNativeExtensionScriptInstanceGetPropertyList)(GDNativeExtensionScriptInstanceDataPtr p_instance, uint32_t *r_count); 327 | typedef void (*GDNativeExtensionScriptInstanceFreePropertyList)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativePropertyInfo *p_list); 328 | typedef GDNativeVariantType (*GDNativeExtensionScriptInstanceGetPropertyType)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeStringNamePtr p_name, GDNativeBool *r_is_valid); 329 | 330 | typedef GDNativeBool (*GDNativeExtensionScriptInstancePropertyCanRevert)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeStringNamePtr p_name); 331 | typedef GDNativeBool (*GDNativeExtensionScriptInstancePropertyGetRevert)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeStringNamePtr p_name, GDNativeVariantPtr r_ret); 332 | 333 | typedef GDNativeObjectPtr (*GDNativeExtensionScriptInstanceGetOwner)(GDNativeExtensionScriptInstanceDataPtr p_instance); 334 | typedef void (*GDNativeExtensionScriptInstancePropertyStateAdd)(const GDNativeStringNamePtr p_name, const GDNativeVariantPtr p_value, void *p_userdata); 335 | typedef void (*GDNativeExtensionScriptInstanceGetPropertyState)(GDNativeExtensionScriptInstanceDataPtr p_instance, GDNativeExtensionScriptInstancePropertyStateAdd p_add_func, void *p_userdata); 336 | 337 | typedef const GDNativeMethodInfo *(*GDNativeExtensionScriptInstanceGetMethodList)(GDNativeExtensionScriptInstanceDataPtr p_instance, uint32_t *r_count); 338 | typedef void (*GDNativeExtensionScriptInstanceFreeMethodList)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeMethodInfo *p_list); 339 | 340 | typedef GDNativeBool (*GDNativeExtensionScriptInstanceHasMethod)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeStringNamePtr p_name); 341 | 342 | typedef void (*GDNativeExtensionScriptInstanceCall)(GDNativeExtensionScriptInstanceDataPtr p_self, const GDNativeStringNamePtr p_method, const GDNativeVariantPtr *p_args, const GDNativeInt p_argument_count, GDNativeVariantPtr r_return, GDNativeCallError *r_error); 343 | typedef void (*GDNativeExtensionScriptInstanceNotification)(GDNativeExtensionScriptInstanceDataPtr p_instance, int32_t p_what); 344 | typedef const char *(*GDNativeExtensionScriptInstanceToString)(GDNativeExtensionScriptInstanceDataPtr p_instance, GDNativeBool *r_is_valid); 345 | 346 | typedef void (*GDNativeExtensionScriptInstanceRefCountIncremented)(GDNativeExtensionScriptInstanceDataPtr p_instance); 347 | typedef GDNativeBool (*GDNativeExtensionScriptInstanceRefCountDecremented)(GDNativeExtensionScriptInstanceDataPtr p_instance); 348 | 349 | typedef GDNativeObjectPtr (*GDNativeExtensionScriptInstanceGetScript)(GDNativeExtensionScriptInstanceDataPtr p_instance); 350 | typedef GDNativeBool (*GDNativeExtensionScriptInstanceIsPlaceholder)(GDNativeExtensionScriptInstanceDataPtr p_instance); 351 | 352 | typedef void *GDNativeExtensionScriptLanguagePtr; 353 | 354 | typedef GDNativeExtensionScriptLanguagePtr (*GDNativeExtensionScriptInstanceGetLanguage)(GDNativeExtensionScriptInstanceDataPtr p_instance); 355 | 356 | typedef void (*GDNativeExtensionScriptInstanceFree)(GDNativeExtensionScriptInstanceDataPtr p_instance); 357 | 358 | typedef void *GDNativeScriptInstancePtr; // Pointer to ScriptInstance. 359 | 360 | typedef struct { 361 | GDNativeExtensionScriptInstanceSet set_func; 362 | GDNativeExtensionScriptInstanceGet get_func; 363 | GDNativeExtensionScriptInstanceGetPropertyList get_property_list_func; 364 | GDNativeExtensionScriptInstanceFreePropertyList free_property_list_func; 365 | GDNativeExtensionScriptInstanceGetPropertyType get_property_type_func; 366 | 367 | GDNativeExtensionScriptInstancePropertyCanRevert property_can_revert_func; 368 | GDNativeExtensionScriptInstancePropertyGetRevert property_get_revert_func; 369 | 370 | GDNativeExtensionScriptInstanceGetOwner get_owner_func; 371 | GDNativeExtensionScriptInstanceGetPropertyState get_property_state_func; 372 | 373 | GDNativeExtensionScriptInstanceGetMethodList get_method_list_func; 374 | GDNativeExtensionScriptInstanceFreeMethodList free_method_list_func; 375 | 376 | GDNativeExtensionScriptInstanceHasMethod has_method_func; 377 | 378 | GDNativeExtensionScriptInstanceCall call_func; 379 | GDNativeExtensionScriptInstanceNotification notification_func; 380 | 381 | GDNativeExtensionScriptInstanceToString to_string_func; 382 | 383 | GDNativeExtensionScriptInstanceRefCountIncremented refcount_incremented_func; 384 | GDNativeExtensionScriptInstanceRefCountDecremented refcount_decremented_func; 385 | 386 | GDNativeExtensionScriptInstanceGetScript get_script_func; 387 | 388 | GDNativeExtensionScriptInstanceIsPlaceholder is_placeholder_func; 389 | 390 | GDNativeExtensionScriptInstanceSet set_fallback_func; 391 | GDNativeExtensionScriptInstanceGet get_fallback_func; 392 | 393 | GDNativeExtensionScriptInstanceGetLanguage get_language_func; 394 | 395 | GDNativeExtensionScriptInstanceFree free_func; 396 | 397 | } GDNativeExtensionScriptInstanceInfo; 398 | 399 | /* INTERFACE */ 400 | 401 | typedef struct { 402 | uint32_t version_major; 403 | uint32_t version_minor; 404 | uint32_t version_patch; 405 | const char *version_string; 406 | 407 | /* GODOT CORE */ 408 | void *(*mem_alloc)(size_t p_bytes); 409 | void *(*mem_realloc)(void *p_ptr, size_t p_bytes); 410 | void (*mem_free)(void *p_ptr); 411 | 412 | void (*print_error)(const char *p_description, const char *p_function, const char *p_file, int32_t p_line); 413 | void (*print_warning)(const char *p_description, const char *p_function, const char *p_file, int32_t p_line); 414 | void (*print_script_error)(const char *p_description, const char *p_function, const char *p_file, int32_t p_line); 415 | 416 | uint64_t (*get_native_struct_size)(const char *p_name); 417 | 418 | /* GODOT VARIANT */ 419 | 420 | /* variant general */ 421 | void (*variant_new_copy)(GDNativeVariantPtr r_dest, const GDNativeVariantPtr p_src); 422 | void (*variant_new_nil)(GDNativeVariantPtr r_dest); 423 | void (*variant_destroy)(GDNativeVariantPtr p_self); 424 | 425 | /* variant type */ 426 | void (*variant_call)(GDNativeVariantPtr p_self, const GDNativeStringNamePtr p_method, const GDNativeVariantPtr *p_args, const GDNativeInt p_argument_count, GDNativeVariantPtr r_return, GDNativeCallError *r_error); 427 | void (*variant_call_static)(GDNativeVariantType p_type, const GDNativeStringNamePtr p_method, const GDNativeVariantPtr *p_args, const GDNativeInt p_argument_count, GDNativeVariantPtr r_return, GDNativeCallError *r_error); 428 | void (*variant_evaluate)(GDNativeVariantOperator p_op, const GDNativeVariantPtr p_a, const GDNativeVariantPtr p_b, GDNativeVariantPtr r_return, GDNativeBool *r_valid); 429 | void (*variant_set)(GDNativeVariantPtr p_self, const GDNativeVariantPtr p_key, const GDNativeVariantPtr p_value, GDNativeBool *r_valid); 430 | void (*variant_set_named)(GDNativeVariantPtr p_self, const GDNativeStringNamePtr p_key, const GDNativeVariantPtr p_value, GDNativeBool *r_valid); 431 | void (*variant_set_keyed)(GDNativeVariantPtr p_self, const GDNativeVariantPtr p_key, const GDNativeVariantPtr p_value, GDNativeBool *r_valid); 432 | void (*variant_set_indexed)(GDNativeVariantPtr p_self, GDNativeInt p_index, const GDNativeVariantPtr p_value, GDNativeBool *r_valid, GDNativeBool *r_oob); 433 | void (*variant_get)(const GDNativeVariantPtr p_self, const GDNativeVariantPtr p_key, GDNativeVariantPtr r_ret, GDNativeBool *r_valid); 434 | void (*variant_get_named)(const GDNativeVariantPtr p_self, const GDNativeStringNamePtr p_key, GDNativeVariantPtr r_ret, GDNativeBool *r_valid); 435 | void (*variant_get_keyed)(const GDNativeVariantPtr p_self, const GDNativeVariantPtr p_key, GDNativeVariantPtr r_ret, GDNativeBool *r_valid); 436 | void (*variant_get_indexed)(const GDNativeVariantPtr p_self, GDNativeInt p_index, GDNativeVariantPtr r_ret, GDNativeBool *r_valid, GDNativeBool *r_oob); 437 | GDNativeBool (*variant_iter_init)(const GDNativeVariantPtr p_self, GDNativeVariantPtr r_iter, GDNativeBool *r_valid); 438 | GDNativeBool (*variant_iter_next)(const GDNativeVariantPtr p_self, GDNativeVariantPtr r_iter, GDNativeBool *r_valid); 439 | void (*variant_iter_get)(const GDNativeVariantPtr p_self, GDNativeVariantPtr r_iter, GDNativeVariantPtr r_ret, GDNativeBool *r_valid); 440 | GDNativeInt (*variant_hash)(const GDNativeVariantPtr p_self); 441 | GDNativeInt (*variant_recursive_hash)(const GDNativeVariantPtr p_self, GDNativeInt p_recursion_count); 442 | GDNativeBool (*variant_hash_compare)(const GDNativeVariantPtr p_self, const GDNativeVariantPtr p_other); 443 | GDNativeBool (*variant_booleanize)(const GDNativeVariantPtr p_self); 444 | void (*variant_sub)(const GDNativeVariantPtr p_a, const GDNativeVariantPtr p_b, GDNativeVariantPtr r_dst); 445 | void (*variant_blend)(const GDNativeVariantPtr p_a, const GDNativeVariantPtr p_b, float p_c, GDNativeVariantPtr r_dst); 446 | void (*variant_interpolate)(const GDNativeVariantPtr p_a, const GDNativeVariantPtr p_b, float p_c, GDNativeVariantPtr r_dst); 447 | void (*variant_duplicate)(const GDNativeVariantPtr p_self, GDNativeVariantPtr r_ret, GDNativeBool p_deep); 448 | void (*variant_stringify)(const GDNativeVariantPtr p_self, GDNativeStringPtr r_ret); 449 | 450 | GDNativeVariantType (*variant_get_type)(const GDNativeVariantPtr p_self); 451 | GDNativeBool (*variant_has_method)(const GDNativeVariantPtr p_self, const GDNativeStringNamePtr p_method); 452 | GDNativeBool (*variant_has_member)(GDNativeVariantType p_type, const GDNativeStringNamePtr p_member); 453 | GDNativeBool (*variant_has_key)(const GDNativeVariantPtr p_self, const GDNativeVariantPtr p_key, GDNativeBool *r_valid); 454 | void (*variant_get_type_name)(GDNativeVariantType p_type, GDNativeStringPtr r_name); 455 | GDNativeBool (*variant_can_convert)(GDNativeVariantType p_from, GDNativeVariantType p_to); 456 | GDNativeBool (*variant_can_convert_strict)(GDNativeVariantType p_from, GDNativeVariantType p_to); 457 | 458 | /* ptrcalls */ 459 | GDNativeVariantFromTypeConstructorFunc (*get_variant_from_type_constructor)(GDNativeVariantType p_type); 460 | GDNativeTypeFromVariantConstructorFunc (*get_variant_to_type_constructor)(GDNativeVariantType p_type); 461 | GDNativePtrOperatorEvaluator (*variant_get_ptr_operator_evaluator)(GDNativeVariantOperator p_operator, GDNativeVariantType p_type_a, GDNativeVariantType p_type_b); 462 | GDNativePtrBuiltInMethod (*variant_get_ptr_builtin_method)(GDNativeVariantType p_type, const char *p_method, GDNativeInt p_hash); 463 | GDNativePtrConstructor (*variant_get_ptr_constructor)(GDNativeVariantType p_type, int32_t p_constructor); 464 | GDNativePtrDestructor (*variant_get_ptr_destructor)(GDNativeVariantType p_type); 465 | void (*variant_construct)(GDNativeVariantType p_type, GDNativeVariantPtr p_base, const GDNativeVariantPtr *p_args, int32_t p_argument_count, GDNativeCallError *r_error); 466 | GDNativePtrSetter (*variant_get_ptr_setter)(GDNativeVariantType p_type, const char *p_member); 467 | GDNativePtrGetter (*variant_get_ptr_getter)(GDNativeVariantType p_type, const char *p_member); 468 | GDNativePtrIndexedSetter (*variant_get_ptr_indexed_setter)(GDNativeVariantType p_type); 469 | GDNativePtrIndexedGetter (*variant_get_ptr_indexed_getter)(GDNativeVariantType p_type); 470 | GDNativePtrKeyedSetter (*variant_get_ptr_keyed_setter)(GDNativeVariantType p_type); 471 | GDNativePtrKeyedGetter (*variant_get_ptr_keyed_getter)(GDNativeVariantType p_type); 472 | GDNativePtrKeyedChecker (*variant_get_ptr_keyed_checker)(GDNativeVariantType p_type); 473 | void (*variant_get_constant_value)(GDNativeVariantType p_type, const char *p_constant, GDNativeVariantPtr r_ret); 474 | GDNativePtrUtilityFunction (*variant_get_ptr_utility_function)(const char *p_function, GDNativeInt p_hash); 475 | 476 | /* extra utilities */ 477 | 478 | void (*string_new_with_latin1_chars)(GDNativeStringPtr r_dest, const char *p_contents); 479 | void (*string_new_with_utf8_chars)(GDNativeStringPtr r_dest, const char *p_contents); 480 | void (*string_new_with_utf16_chars)(GDNativeStringPtr r_dest, const char16_t *p_contents); 481 | void (*string_new_with_utf32_chars)(GDNativeStringPtr r_dest, const char32_t *p_contents); 482 | void (*string_new_with_wide_chars)(GDNativeStringPtr r_dest, const wchar_t *p_contents); 483 | void (*string_new_with_latin1_chars_and_len)(GDNativeStringPtr r_dest, const char *p_contents, const GDNativeInt p_size); 484 | void (*string_new_with_utf8_chars_and_len)(GDNativeStringPtr r_dest, const char *p_contents, const GDNativeInt p_size); 485 | void (*string_new_with_utf16_chars_and_len)(GDNativeStringPtr r_dest, const char16_t *p_contents, const GDNativeInt p_size); 486 | void (*string_new_with_utf32_chars_and_len)(GDNativeStringPtr r_dest, const char32_t *p_contents, const GDNativeInt p_size); 487 | void (*string_new_with_wide_chars_and_len)(GDNativeStringPtr r_dest, const wchar_t *p_contents, const GDNativeInt p_size); 488 | /* Information about the following functions: 489 | * - The return value is the resulting encoded string length. 490 | * - The length returned is in characters, not in bytes. It also does not include a trailing zero. 491 | * - These functions also do not write trailing zero, If you need it, write it yourself at the position indicated by the length (and make sure to allocate it). 492 | * - Passing NULL in r_text means only the length is computed (again, without including trailing zero). 493 | * - p_max_write_length argument is in characters, not bytes. It will be ignored if r_text is NULL. 494 | * - p_max_write_length argument does not affect the return value, it's only to cap write length. 495 | */ 496 | GDNativeInt (*string_to_latin1_chars)(const GDNativeStringPtr p_self, char *r_text, GDNativeInt p_max_write_length); 497 | GDNativeInt (*string_to_utf8_chars)(const GDNativeStringPtr p_self, char *r_text, GDNativeInt p_max_write_length); 498 | GDNativeInt (*string_to_utf16_chars)(const GDNativeStringPtr p_self, char16_t *r_text, GDNativeInt p_max_write_length); 499 | GDNativeInt (*string_to_utf32_chars)(const GDNativeStringPtr p_self, char32_t *r_text, GDNativeInt p_max_write_length); 500 | GDNativeInt (*string_to_wide_chars)(const GDNativeStringPtr p_self, wchar_t *r_text, GDNativeInt p_max_write_length); 501 | char32_t *(*string_operator_index)(GDNativeStringPtr p_self, GDNativeInt p_index); 502 | const char32_t *(*string_operator_index_const)(const GDNativeStringPtr p_self, GDNativeInt p_index); 503 | 504 | /* Packed array functions */ 505 | 506 | uint8_t *(*packed_byte_array_operator_index)(GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be a PackedByteArray 507 | const uint8_t *(*packed_byte_array_operator_index_const)(const GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be a PackedByteArray 508 | 509 | GDNativeTypePtr (*packed_color_array_operator_index)(GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be a PackedColorArray, returns Color ptr 510 | GDNativeTypePtr (*packed_color_array_operator_index_const)(const GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be a PackedColorArray, returns Color ptr 511 | 512 | float *(*packed_float32_array_operator_index)(GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be a PackedFloat32Array 513 | const float *(*packed_float32_array_operator_index_const)(const GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be a PackedFloat32Array 514 | double *(*packed_float64_array_operator_index)(GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be a PackedFloat64Array 515 | const double *(*packed_float64_array_operator_index_const)(const GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be a PackedFloat64Array 516 | 517 | int32_t *(*packed_int32_array_operator_index)(GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be a PackedInt32Array 518 | const int32_t *(*packed_int32_array_operator_index_const)(const GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be a PackedInt32Array 519 | int64_t *(*packed_int64_array_operator_index)(GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be a PackedInt32Array 520 | const int64_t *(*packed_int64_array_operator_index_const)(const GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be a PackedInt32Array 521 | 522 | GDNativeStringPtr (*packed_string_array_operator_index)(GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be a PackedStringArray 523 | GDNativeStringPtr (*packed_string_array_operator_index_const)(const GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be a PackedStringArray 524 | 525 | GDNativeTypePtr (*packed_vector2_array_operator_index)(GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be a PackedVector2Array, returns Vector2 ptr 526 | GDNativeTypePtr (*packed_vector2_array_operator_index_const)(const GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be a PackedVector2Array, returns Vector2 ptr 527 | GDNativeTypePtr (*packed_vector3_array_operator_index)(GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be a PackedVector3Array, returns Vector3 ptr 528 | GDNativeTypePtr (*packed_vector3_array_operator_index_const)(const GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be a PackedVector3Array, returns Vector3 ptr 529 | 530 | GDNativeVariantPtr (*array_operator_index)(GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be an Array ptr 531 | GDNativeVariantPtr (*array_operator_index_const)(const GDNativeTypePtr p_self, GDNativeInt p_index); // p_self should be an Array ptr 532 | 533 | /* Dictionary functions */ 534 | 535 | GDNativeVariantPtr (*dictionary_operator_index)(GDNativeTypePtr p_self, const GDNativeVariantPtr p_key); // p_self should be an Dictionary ptr 536 | GDNativeVariantPtr (*dictionary_operator_index_const)(const GDNativeTypePtr p_self, const GDNativeVariantPtr p_key); // p_self should be an Dictionary ptr 537 | 538 | /* OBJECT */ 539 | 540 | void (*object_method_bind_call)(const GDNativeMethodBindPtr p_method_bind, GDNativeObjectPtr p_instance, const GDNativeVariantPtr *p_args, GDNativeInt p_arg_count, GDNativeVariantPtr r_ret, GDNativeCallError *r_error); 541 | void (*object_method_bind_ptrcall)(const GDNativeMethodBindPtr p_method_bind, GDNativeObjectPtr p_instance, const GDNativeTypePtr *p_args, GDNativeTypePtr r_ret); 542 | void (*object_destroy)(GDNativeObjectPtr p_o); 543 | GDNativeObjectPtr (*global_get_singleton)(const char *p_name); 544 | 545 | void *(*object_get_instance_binding)(GDNativeObjectPtr p_o, void *p_token, const GDNativeInstanceBindingCallbacks *p_callbacks); 546 | void (*object_set_instance_binding)(GDNativeObjectPtr p_o, void *p_token, void *p_binding, const GDNativeInstanceBindingCallbacks *p_callbacks); 547 | 548 | void (*object_set_instance)(GDNativeObjectPtr p_o, const char *p_classname, GDExtensionClassInstancePtr p_instance); /* p_classname should be a registered extension class and should extend the p_o object's class. */ 549 | 550 | GDNativeObjectPtr (*object_cast_to)(const GDNativeObjectPtr p_object, void *p_class_tag); 551 | GDNativeObjectPtr (*object_get_instance_from_id)(GDObjectInstanceID p_instance_id); 552 | GDObjectInstanceID (*object_get_instance_id)(const GDNativeObjectPtr p_object); 553 | 554 | /* SCRIPT INSTANCE */ 555 | 556 | GDNativeScriptInstancePtr (*script_instance_create)(const GDNativeExtensionScriptInstanceInfo *p_info, GDNativeExtensionScriptInstanceDataPtr p_instance_data); 557 | 558 | /* CLASSDB */ 559 | GDNativeObjectPtr (*classdb_construct_object)(const char *p_classname); /* The passed class must be a built-in godot class, or an already-registered extension class. In both case, object_set_instance should be called to fully initialize the object. */ 560 | GDNativeMethodBindPtr (*classdb_get_method_bind)(const char *p_classname, const char *p_methodname, GDNativeInt p_hash); 561 | void *(*classdb_get_class_tag)(const char *p_classname); 562 | 563 | /* CLASSDB EXTENSION */ 564 | 565 | void (*classdb_register_extension_class)(const GDNativeExtensionClassLibraryPtr p_library, const char *p_class_name, const char *p_parent_class_name, const GDNativeExtensionClassCreationInfo *p_extension_funcs); 566 | void (*classdb_register_extension_class_method)(const GDNativeExtensionClassLibraryPtr p_library, const char *p_class_name, const GDNativeExtensionClassMethodInfo *p_method_info); 567 | void (*classdb_register_extension_class_integer_constant)(const GDNativeExtensionClassLibraryPtr p_library, const char *p_class_name, const char *p_enum_name, const char *p_constant_name, GDNativeInt p_constant_value, GDNativeBool p_is_bitfield); 568 | void (*classdb_register_extension_class_property)(const GDNativeExtensionClassLibraryPtr p_library, const char *p_class_name, const GDNativePropertyInfo *p_info, const char *p_setter, const char *p_getter); 569 | void (*classdb_register_extension_class_property_group)(const GDNativeExtensionClassLibraryPtr p_library, const char *p_class_name, const char *p_group_name, const char *p_prefix); 570 | void (*classdb_register_extension_class_property_subgroup)(const GDNativeExtensionClassLibraryPtr p_library, const char *p_class_name, const char *p_subgroup_name, const char *p_prefix); 571 | void (*classdb_register_extension_class_signal)(const GDNativeExtensionClassLibraryPtr p_library, const char *p_class_name, const char *p_signal_name, const GDNativePropertyInfo *p_argument_info, GDNativeInt p_argument_count); 572 | void (*classdb_unregister_extension_class)(const GDNativeExtensionClassLibraryPtr p_library, const char *p_class_name); /* Unregistering a parent class before a class that inherits it will result in failure. Inheritors must be unregistered first. */ 573 | 574 | void (*get_library_path)(const GDNativeExtensionClassLibraryPtr p_library, GDNativeStringPtr r_path); 575 | 576 | } GDNativeInterface; 577 | 578 | /* INITIALIZATION */ 579 | 580 | typedef enum { 581 | GDNATIVE_INITIALIZATION_CORE, 582 | GDNATIVE_INITIALIZATION_SERVERS, 583 | GDNATIVE_INITIALIZATION_SCENE, 584 | GDNATIVE_INITIALIZATION_EDITOR, 585 | GDNATIVE_MAX_INITIALIZATION_LEVEL, 586 | } GDNativeInitializationLevel; 587 | 588 | typedef struct { 589 | /* Minimum initialization level required. 590 | * If Core or Servers, the extension needs editor or game restart to take effect */ 591 | GDNativeInitializationLevel minimum_initialization_level; 592 | /* Up to the user to supply when initializing */ 593 | void *userdata; 594 | /* This function will be called multiple times for each initialization level. */ 595 | void (*initialize)(void *userdata, GDNativeInitializationLevel p_level); 596 | void (*deinitialize)(void *userdata, GDNativeInitializationLevel p_level); 597 | } GDNativeInitialization; 598 | 599 | /* Define a C function prototype that implements the function below and expose it to dlopen() (or similar). 600 | * It will be called on initialization. The name must be an unique one specified in the .gdextension config file. 601 | */ 602 | 603 | typedef GDNativeBool (*GDNativeInitializationFunction)(const GDNativeInterface *p_interface, const GDNativeExtensionClassLibraryPtr p_library, GDNativeInitialization *r_initialization); 604 | 605 | #ifdef __cplusplus 606 | } 607 | #endif 608 | 609 | #endif // GDNATIVE_INTERFACE_H 610 | -------------------------------------------------------------------------------- /godot-headers/godot/gdnative_interface.nim: -------------------------------------------------------------------------------- 1 | ## *********************************************************************** 2 | ## gdnative_interface.h 3 | ## *********************************************************************** 4 | ## This file is part of: 5 | ## GODOT ENGINE 6 | ## https://godotengine.org 7 | ## *********************************************************************** 8 | ## Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. 9 | ## Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). 10 | ## 11 | ## Permission is hereby granted, free of charge, to any person obtaining 12 | ## a copy of this software and associated documentation files (the 13 | ## "Software"), to deal in the Software without restriction, including 14 | ## without limitation the rights to use, copy, modify, merge, publish, 15 | ## distribute, sublicense, and/or sell copies of the Software, and to 16 | ## permit persons to whom the Software is furnished to do so, subject to 17 | ## the following conditions: 18 | ## 19 | ## The above copyright notice and this permission notice shall be 20 | ## included in all copies or substantial portions of the Software. 21 | ## 22 | ## THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 23 | ## EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 24 | ## MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 25 | ## IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 26 | ## CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 27 | ## TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 28 | ## SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 29 | ## *********************************************************************** 30 | 31 | ## This is a C class header, you can copy it and use it directly in your own binders. 32 | ## Together with the JSON file, you should be able to generate any binder. 33 | ## 34 | 35 | type 36 | char32_t* = uint32 37 | char16_t* = uint16 38 | 39 | ## VARIANT TYPES 40 | 41 | type ## comparison 42 | GDNativeVariantType* = enum 43 | GDNATIVE_VARIANT_TYPE_NIL, ## atomic types 44 | GDNATIVE_VARIANT_TYPE_BOOL, GDNATIVE_VARIANT_TYPE_INT, 45 | GDNATIVE_VARIANT_TYPE_FLOAT, GDNATIVE_VARIANT_TYPE_STRING, ## math types 46 | GDNATIVE_VARIANT_TYPE_VECTOR2, GDNATIVE_VARIANT_TYPE_VECTOR2I, 47 | GDNATIVE_VARIANT_TYPE_RECT2, GDNATIVE_VARIANT_TYPE_RECT2I, 48 | GDNATIVE_VARIANT_TYPE_VECTOR3, GDNATIVE_VARIANT_TYPE_VECTOR3I, 49 | GDNATIVE_VARIANT_TYPE_TRANSFORM2D, GDNATIVE_VARIANT_TYPE_VECTOR4, 50 | GDNATIVE_VARIANT_TYPE_VECTOR4I, GDNATIVE_VARIANT_TYPE_PLANE, 51 | GDNATIVE_VARIANT_TYPE_QUATERNION, GDNATIVE_VARIANT_TYPE_AABB, 52 | GDNATIVE_VARIANT_TYPE_BASIS, GDNATIVE_VARIANT_TYPE_TRANSFORM3D, GDNATIVE_VARIANT_TYPE_PROJECTION, ## misc types 53 | GDNATIVE_VARIANT_TYPE_COLOR, GDNATIVE_VARIANT_TYPE_STRING_NAME, 54 | GDNATIVE_VARIANT_TYPE_NODE_PATH, GDNATIVE_VARIANT_TYPE_RID, 55 | GDNATIVE_VARIANT_TYPE_OBJECT, GDNATIVE_VARIANT_TYPE_CALLABLE, 56 | GDNATIVE_VARIANT_TYPE_SIGNAL, GDNATIVE_VARIANT_TYPE_DICTIONARY, GDNATIVE_VARIANT_TYPE_ARRAY, ## typed arrays 57 | GDNATIVE_VARIANT_TYPE_PACKED_BYTE_ARRAY, 58 | GDNATIVE_VARIANT_TYPE_PACKED_INT32_ARRAY, 59 | GDNATIVE_VARIANT_TYPE_PACKED_INT64_ARRAY, 60 | GDNATIVE_VARIANT_TYPE_PACKED_FLOAT32_ARRAY, 61 | GDNATIVE_VARIANT_TYPE_PACKED_FLOAT64_ARRAY, 62 | GDNATIVE_VARIANT_TYPE_PACKED_STRING_ARRAY, 63 | GDNATIVE_VARIANT_TYPE_PACKED_VECTOR2_ARRAY, 64 | GDNATIVE_VARIANT_TYPE_PACKED_VECTOR3_ARRAY, 65 | GDNATIVE_VARIANT_TYPE_PACKED_COLOR_ARRAY, GDNATIVE_VARIANT_TYPE_VARIANT_MAX 66 | GDNativeVariantOperator* = enum 67 | GDNATIVE_VARIANT_OP_EQUAL, GDNATIVE_VARIANT_OP_NOT_EQUAL, 68 | GDNATIVE_VARIANT_OP_LESS, GDNATIVE_VARIANT_OP_LESS_EQUAL, 69 | GDNATIVE_VARIANT_OP_GREATER, GDNATIVE_VARIANT_OP_GREATER_EQUAL, ## mathematic 70 | GDNATIVE_VARIANT_OP_ADD, GDNATIVE_VARIANT_OP_SUBTRACT, 71 | GDNATIVE_VARIANT_OP_MULTIPLY, GDNATIVE_VARIANT_OP_DIVIDE, 72 | GDNATIVE_VARIANT_OP_NEGATE, GDNATIVE_VARIANT_OP_POSITIVE, 73 | GDNATIVE_VARIANT_OP_MODULE, GDNATIVE_VARIANT_OP_POWER, ## bitwise 74 | GDNATIVE_VARIANT_OP_SHIFT_LEFT, GDNATIVE_VARIANT_OP_SHIFT_RIGHT, 75 | GDNATIVE_VARIANT_OP_BIT_AND, GDNATIVE_VARIANT_OP_BIT_OR, 76 | GDNATIVE_VARIANT_OP_BIT_XOR, GDNATIVE_VARIANT_OP_BIT_NEGATE, ## logic 77 | GDNATIVE_VARIANT_OP_AND, GDNATIVE_VARIANT_OP_OR, GDNATIVE_VARIANT_OP_XOR, GDNATIVE_VARIANT_OP_NOT, ## containment 78 | GDNATIVE_VARIANT_OP_IN, GDNATIVE_VARIANT_OP_MAX 79 | GDNativeVariantPtr* = pointer 80 | GDNativeStringNamePtr* = pointer 81 | GDNativeStringPtr* = pointer 82 | GDNativeObjectPtr* = pointer 83 | GDNativeTypePtr* = pointer 84 | GDNativeExtensionPtr* = pointer 85 | GDNativeMethodBindPtr* = pointer 86 | GDNativeInt* = int64 87 | GDNativeBool* = uint8 88 | GDObjectInstanceID* = uint64 89 | 90 | 91 | 92 | ## VARIANT DATA I/O 93 | 94 | type 95 | GDNativeCallErrorType* = enum 96 | GDNATIVE_CALL_OK, GDNATIVE_CALL_ERROR_INVALID_METHOD, GDNATIVE_CALL_ERROR_INVALID_ARGUMENT, ## expected is variant type 97 | GDNATIVE_CALL_ERROR_TOO_MANY_ARGUMENTS, ## expected is number of arguments 98 | GDNATIVE_CALL_ERROR_TOO_FEW_ARGUMENTS, ## expected is number of arguments 99 | GDNATIVE_CALL_ERROR_INSTANCE_IS_NULL, GDNATIVE_CALL_ERROR_METHOD_NOT_CONST ## used for const call 100 | GDNativeCallError* {.bycopy.} = object 101 | error*: GDNativeCallErrorType 102 | argument*: int32 103 | expected*: int32 104 | 105 | GDNativeVariantFromTypeConstructorFunc* = proc (a1: GDNativeVariantPtr; 106 | a2: GDNativeTypePtr) {.cdecl.} 107 | GDNativeTypeFromVariantConstructorFunc* = proc (a1: GDNativeTypePtr; 108 | a2: GDNativeVariantPtr) {.cdecl.} 109 | GDNativePtrOperatorEvaluator* = proc (p_left: GDNativeTypePtr; 110 | p_right: GDNativeTypePtr; 111 | r_result: GDNativeTypePtr) {.cdecl.} 112 | GDNativePtrBuiltInMethod* = proc (p_base: GDNativeTypePtr; 113 | p_args: ptr GDNativeTypePtr; 114 | r_return: GDNativeTypePtr; p_argument_count: cint) {. 115 | cdecl.} 116 | GDNativePtrConstructor* = proc (p_base: GDNativeTypePtr; 117 | p_args: ptr GDNativeTypePtr) {.cdecl.} 118 | GDNativePtrDestructor* = proc (p_base: GDNativeTypePtr) {.cdecl.} 119 | GDNativePtrSetter* = proc (p_base: GDNativeTypePtr; p_value: GDNativeTypePtr) {.cdecl.} 120 | GDNativePtrGetter* = proc (p_base: GDNativeTypePtr; r_value: GDNativeTypePtr) {.cdecl.} 121 | GDNativePtrIndexedSetter* = proc (p_base: GDNativeTypePtr; p_index: GDNativeInt; 122 | p_value: GDNativeTypePtr) {.cdecl.} 123 | GDNativePtrIndexedGetter* = proc (p_base: GDNativeTypePtr; p_index: GDNativeInt; 124 | r_value: GDNativeTypePtr) {.cdecl.} 125 | GDNativePtrKeyedSetter* = proc (p_base: GDNativeTypePtr; p_key: GDNativeTypePtr; 126 | p_value: GDNativeTypePtr) {.cdecl.} 127 | GDNativePtrKeyedGetter* = proc (p_base: GDNativeTypePtr; p_key: GDNativeTypePtr; 128 | r_value: GDNativeTypePtr) {.cdecl.} 129 | GDNativePtrKeyedChecker* = proc (p_base: GDNativeVariantPtr; 130 | p_key: GDNativeVariantPtr): uint32 {.cdecl.} 131 | GDNativePtrUtilityFunction* = proc (r_return: GDNativeTypePtr; 132 | p_arguments: ptr GDNativeTypePtr; 133 | p_argument_count: cint) {.cdecl.} 134 | GDNativeClassConstructor* = proc (): GDNativeObjectPtr {.cdecl.} 135 | GDNativeInstanceBindingCreateCallback* = proc (p_token: pointer; 136 | p_instance: pointer): pointer {.cdecl.} 137 | GDNativeInstanceBindingFreeCallback* = proc (p_token: pointer; p_instance: pointer; 138 | p_binding: pointer) {.cdecl.} 139 | GDNativeInstanceBindingReferenceCallback* = proc (p_token: pointer; 140 | p_binding: pointer; p_reference: GDNativeBool): GDNativeBool {.cdecl.} 141 | GDNativeInstanceBindingCallbacks* {.bycopy.} = object 142 | create_callback*: GDNativeInstanceBindingCreateCallback 143 | free_callback*: GDNativeInstanceBindingFreeCallback 144 | reference_callback*: GDNativeInstanceBindingReferenceCallback 145 | 146 | 147 | 148 | ## EXTENSION CLASSES 149 | 150 | type 151 | GDExtensionClassInstancePtr* = pointer 152 | GDNativeExtensionClassSet* = proc (p_instance: GDExtensionClassInstancePtr; 153 | p_name: GDNativeStringNamePtr; 154 | p_value: GDNativeVariantPtr): GDNativeBool {. 155 | cdecl.} 156 | GDNativeExtensionClassGet* = proc (p_instance: GDExtensionClassInstancePtr; 157 | p_name: GDNativeStringNamePtr; 158 | r_ret: GDNativeVariantPtr): GDNativeBool {.cdecl.} 159 | GDNativeExtensionClassGetRID* = proc (p_instance: GDExtensionClassInstancePtr): uint64 {. 160 | cdecl.} 161 | GDNativePropertyInfo* {.bycopy.} = object 162 | `type`*: uint32 163 | name*: cstring 164 | class_name*: cstring 165 | hint*: uint32 166 | hint_string*: cstring 167 | usage*: uint32 168 | 169 | GDNativeMethodInfo* {.bycopy.} = object 170 | name*: cstring 171 | return_value*: GDNativePropertyInfo 172 | flags*: uint32 ## From GDNativeExtensionClassMethodFlags 173 | id*: int32 174 | arguments*: ptr GDNativePropertyInfo 175 | argument_count*: uint32 176 | default_arguments*: GDNativeVariantPtr 177 | default_argument_count*: uint32 178 | 179 | GDNativeExtensionClassGetPropertyList* = proc ( 180 | p_instance: GDExtensionClassInstancePtr; r_count: ptr uint32): ptr GDNativePropertyInfo {. 181 | cdecl.} 182 | GDNativeExtensionClassFreePropertyList* = proc ( 183 | p_instance: GDExtensionClassInstancePtr; p_list: ptr GDNativePropertyInfo) {. 184 | cdecl.} 185 | GDNativeExtensionClassPropertyCanRevert* = proc ( 186 | p_instance: GDExtensionClassInstancePtr; p_name: GDNativeStringNamePtr): GDNativeBool {. 187 | cdecl.} 188 | GDNativeExtensionClassPropertyGetRevert* = proc ( 189 | p_instance: GDExtensionClassInstancePtr; p_name: GDNativeStringNamePtr; 190 | r_ret: GDNativeVariantPtr): GDNativeBool {.cdecl.} 191 | GDNativeExtensionClassNotification* = proc ( 192 | p_instance: GDExtensionClassInstancePtr; p_what: int32) {.cdecl.} 193 | GDNativeExtensionClassToString* = proc (p_instance: GDExtensionClassInstancePtr; 194 | p_out: GDNativeStringPtr) {.cdecl.} 195 | GDNativeExtensionClassReference* = proc (p_instance: GDExtensionClassInstancePtr) {. 196 | cdecl.} 197 | GDNativeExtensionClassUnreference* = proc ( 198 | p_instance: GDExtensionClassInstancePtr) {.cdecl.} 199 | GDNativeExtensionClassCallVirtual* = proc ( 200 | p_instance: GDExtensionClassInstancePtr; p_args: ptr GDNativeTypePtr; 201 | r_ret: GDNativeTypePtr) {.cdecl.} 202 | GDNativeExtensionClassCreateInstance* = proc (p_userdata: pointer): GDNativeObjectPtr {. 203 | cdecl.} 204 | GDNativeExtensionClassFreeInstance* = proc (p_userdata: pointer; 205 | p_instance: GDExtensionClassInstancePtr) {.cdecl.} 206 | GDNativeExtensionClassObjectInstance* = proc ( 207 | p_instance: GDExtensionClassInstancePtr; 208 | p_object_instance: GDNativeObjectPtr) {.cdecl.} 209 | GDNativeExtensionClassGetVirtual* = proc (p_userdata: pointer; p_name: cstring): GDNativeExtensionClassCallVirtual {. 210 | cdecl.} 211 | GDNativeExtensionClassCreationInfo* {.bycopy.} = object 212 | set_func*: GDNativeExtensionClassSet 213 | get_func*: GDNativeExtensionClassGet 214 | get_property_list_func*: GDNativeExtensionClassGetPropertyList 215 | free_property_list_func*: GDNativeExtensionClassFreePropertyList 216 | property_can_revert_func*: GDNativeExtensionClassPropertyCanRevert 217 | property_get_revert_func*: GDNativeExtensionClassPropertyGetRevert 218 | notification_func*: GDNativeExtensionClassNotification 219 | to_string_func*: GDNativeExtensionClassToString 220 | reference_func*: GDNativeExtensionClassReference 221 | unreference_func*: GDNativeExtensionClassUnreference 222 | create_instance_func*: GDNativeExtensionClassCreateInstance ## this one is mandatory 223 | free_instance_func*: GDNativeExtensionClassFreeInstance ## this one is mandatory 224 | get_virtual_func*: GDNativeExtensionClassGetVirtual 225 | get_rid_func*: GDNativeExtensionClassGetRID 226 | class_userdata*: pointer 227 | 228 | GDNativeExtensionClassLibraryPtr* = pointer 229 | 230 | ## Method 231 | 232 | type 233 | GDNativeExtensionClassMethodFlags* = enum 234 | GDNATIVE_EXTENSION_METHOD_FLAG_NORMAL = 1, 235 | GDNATIVE_EXTENSION_METHOD_FLAG_EDITOR = 2, 236 | GDNATIVE_EXTENSION_METHOD_FLAG_CONST = 4, 237 | GDNATIVE_EXTENSION_METHOD_FLAG_VIRTUAL = 8, 238 | GDNATIVE_EXTENSION_METHOD_FLAG_VARARG = 16, 239 | GDNATIVE_EXTENSION_METHOD_FLAG_STATIC = 32 240 | GDNativeExtensionClassMethodArgumentMetadata* = enum 241 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_NONE, 242 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_INT8, 243 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_INT16, 244 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_INT32, 245 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_INT64, 246 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_UINT8, 247 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_UINT16, 248 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_UINT32, 249 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_UINT64, 250 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_REAL_IS_FLOAT, 251 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_REAL_IS_DOUBLE 252 | GDNativeExtensionClassMethodCall* = proc (method_userdata: pointer; 253 | p_instance: GDExtensionClassInstancePtr; p_args: ptr GDNativeVariantPtr; 254 | p_argument_count: GDNativeInt; r_return: GDNativeVariantPtr; 255 | r_error: ptr GDNativeCallError) {.cdecl.} 256 | GDNativeExtensionClassMethodPtrCall* = proc (method_userdata: pointer; 257 | p_instance: GDExtensionClassInstancePtr; p_args: ptr GDNativeTypePtr; 258 | r_ret: GDNativeTypePtr) {.cdecl.} 259 | 260 | const 261 | GDNATIVE_EXTENSION_METHOD_FLAGS_DEFAULT* = GDNATIVE_EXTENSION_METHOD_FLAG_NORMAL 262 | 263 | 264 | ## passing -1 as argument in the following functions refers to the return type 265 | 266 | type 267 | GDNativeExtensionClassMethodGetArgumentType* = proc (p_method_userdata: pointer; 268 | p_argument: int32): GDNativeVariantType {.cdecl.} 269 | GDNativeExtensionClassMethodGetArgumentInfo* = proc (p_method_userdata: pointer; 270 | p_argument: int32; r_info: ptr GDNativePropertyInfo) {.cdecl.} 271 | GDNativeExtensionClassMethodGetArgumentMetadata* = proc ( 272 | p_method_userdata: pointer; p_argument: int32): GDNativeExtensionClassMethodArgumentMetadata {. 273 | cdecl.} 274 | GDNativeExtensionClassMethodInfo* {.bycopy.} = object 275 | name*: cstring 276 | method_userdata*: pointer 277 | call_func*: GDNativeExtensionClassMethodCall 278 | ptrcall_func*: GDNativeExtensionClassMethodPtrCall 279 | method_flags*: uint32 ## GDNativeExtensionClassMethodFlags 280 | argument_count*: uint32 281 | has_return_value*: GDNativeBool 282 | get_argument_type_func*: GDNativeExtensionClassMethodGetArgumentType 283 | get_argument_info_func*: GDNativeExtensionClassMethodGetArgumentInfo ## name and hint information for the argument can be omitted in release builds. Class name should always be present if it applies. 284 | get_argument_metadata_func*: GDNativeExtensionClassMethodGetArgumentMetadata 285 | default_argument_count*: uint32 286 | default_arguments*: ptr GDNativeVariantPtr 287 | 288 | 289 | ## SCRIPT INSTANCE EXTENSION 290 | 291 | type 292 | GDNativeExtensionScriptInstanceDataPtr* = pointer 293 | 294 | ## Pointer to custom ScriptInstance native implementation 295 | 296 | type 297 | GDNativeExtensionScriptInstanceSet* = proc ( 298 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 299 | p_name: GDNativeStringNamePtr; p_value: GDNativeVariantPtr): GDNativeBool {. 300 | cdecl.} 301 | GDNativeExtensionScriptInstanceGet* = proc ( 302 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 303 | p_name: GDNativeStringNamePtr; r_ret: GDNativeVariantPtr): GDNativeBool {.cdecl.} 304 | GDNativeExtensionScriptInstanceGetPropertyList* = proc ( 305 | p_instance: GDNativeExtensionScriptInstanceDataPtr; r_count: ptr uint32): ptr GDNativePropertyInfo {. 306 | cdecl.} 307 | GDNativeExtensionScriptInstanceFreePropertyList* = proc ( 308 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 309 | p_list: ptr GDNativePropertyInfo) {.cdecl.} 310 | GDNativeExtensionScriptInstanceGetPropertyType* = proc ( 311 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 312 | p_name: GDNativeStringNamePtr; r_is_valid: ptr GDNativeBool): GDNativeVariantType {. 313 | cdecl.} 314 | GDNativeExtensionScriptInstancePropertyCanRevert* = proc ( 315 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 316 | p_name: GDNativeStringNamePtr): GDNativeBool {.cdecl.} 317 | GDNativeExtensionScriptInstancePropertyGetRevert* = proc ( 318 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 319 | p_name: GDNativeStringNamePtr; r_ret: GDNativeVariantPtr): GDNativeBool {.cdecl.} 320 | GDNativeExtensionScriptInstanceGetOwner* = proc ( 321 | p_instance: GDNativeExtensionScriptInstanceDataPtr): GDNativeObjectPtr {. 322 | cdecl.} 323 | GDNativeExtensionScriptInstancePropertyStateAdd* = proc ( 324 | p_name: GDNativeStringNamePtr; p_value: GDNativeVariantPtr; 325 | p_userdata: pointer) {.cdecl.} 326 | GDNativeExtensionScriptInstanceGetPropertyState* = proc ( 327 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 328 | p_add_func: GDNativeExtensionScriptInstancePropertyStateAdd; 329 | p_userdata: pointer) {.cdecl.} 330 | GDNativeExtensionScriptInstanceGetMethodList* = proc ( 331 | p_instance: GDNativeExtensionScriptInstanceDataPtr; r_count: ptr uint32): ptr GDNativeMethodInfo {. 332 | cdecl.} 333 | GDNativeExtensionScriptInstanceFreeMethodList* = proc ( 334 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 335 | p_list: ptr GDNativeMethodInfo) {.cdecl.} 336 | GDNativeExtensionScriptInstanceHasMethod* = proc ( 337 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 338 | p_name: GDNativeStringNamePtr): GDNativeBool {.cdecl.} 339 | GDNativeExtensionScriptInstanceCall* = proc ( 340 | p_self: GDNativeExtensionScriptInstanceDataPtr; 341 | p_method: GDNativeStringNamePtr; p_args: ptr GDNativeVariantPtr; 342 | p_argument_count: GDNativeInt; r_return: GDNativeVariantPtr; 343 | r_error: ptr GDNativeCallError) {.cdecl.} 344 | GDNativeExtensionScriptInstanceNotification* = proc ( 345 | p_instance: GDNativeExtensionScriptInstanceDataPtr; p_what: int32) {.cdecl.} 346 | GDNativeExtensionScriptInstanceToString* = proc ( 347 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 348 | r_is_valid: ptr GDNativeBool): cstring {.cdecl.} 349 | GDNativeExtensionScriptInstanceRefCountIncremented* = proc ( 350 | p_instance: GDNativeExtensionScriptInstanceDataPtr) {.cdecl.} 351 | GDNativeExtensionScriptInstanceRefCountDecremented* = proc ( 352 | p_instance: GDNativeExtensionScriptInstanceDataPtr): GDNativeBool {.cdecl.} 353 | GDNativeExtensionScriptInstanceGetScript* = proc ( 354 | p_instance: GDNativeExtensionScriptInstanceDataPtr): GDNativeObjectPtr {. 355 | cdecl.} 356 | GDNativeExtensionScriptInstanceIsPlaceholder* = proc ( 357 | p_instance: GDNativeExtensionScriptInstanceDataPtr): GDNativeBool {.cdecl.} 358 | GDNativeExtensionScriptLanguagePtr* = pointer 359 | GDNativeExtensionScriptInstanceGetLanguage* = proc ( 360 | p_instance: GDNativeExtensionScriptInstanceDataPtr): GDNativeExtensionScriptLanguagePtr {. 361 | cdecl.} 362 | GDNativeExtensionScriptInstanceFree* = proc ( 363 | p_instance: GDNativeExtensionScriptInstanceDataPtr) {.cdecl.} 364 | GDNativeScriptInstancePtr* = pointer 365 | 366 | ## Pointer to ScriptInstance. 367 | 368 | type 369 | GDNativeExtensionScriptInstanceInfo* {.bycopy.} = object 370 | set_func*: GDNativeExtensionScriptInstanceSet 371 | get_func*: GDNativeExtensionScriptInstanceGet 372 | get_property_list_func*: GDNativeExtensionScriptInstanceGetPropertyList 373 | free_property_list_func*: GDNativeExtensionScriptInstanceFreePropertyList 374 | get_property_type_func*: GDNativeExtensionScriptInstanceGetPropertyType 375 | property_can_revert_func*: GDNativeExtensionScriptInstancePropertyCanRevert 376 | property_get_revert_func*: GDNativeExtensionScriptInstancePropertyGetRevert 377 | get_owner_func*: GDNativeExtensionScriptInstanceGetOwner 378 | get_property_state_func*: GDNativeExtensionScriptInstanceGetPropertyState 379 | get_method_list_func*: GDNativeExtensionScriptInstanceGetMethodList 380 | free_method_list_func*: GDNativeExtensionScriptInstanceFreeMethodList 381 | has_method_func*: GDNativeExtensionScriptInstanceHasMethod 382 | call_func*: GDNativeExtensionScriptInstanceCall 383 | notification_func*: GDNativeExtensionScriptInstanceNotification 384 | to_string_func*: GDNativeExtensionScriptInstanceToString 385 | refcount_incremented_func*: GDNativeExtensionScriptInstanceRefCountIncremented 386 | refcount_decremented_func*: GDNativeExtensionScriptInstanceRefCountDecremented 387 | get_script_func*: GDNativeExtensionScriptInstanceGetScript 388 | is_placeholder_func*: GDNativeExtensionScriptInstanceIsPlaceholder 389 | set_fallback_func*: GDNativeExtensionScriptInstanceSet 390 | get_fallback_func*: GDNativeExtensionScriptInstanceGet 391 | get_language_func*: GDNativeExtensionScriptInstanceGetLanguage 392 | free_func*: GDNativeExtensionScriptInstanceFree 393 | 394 | 395 | ## INTERFACE 396 | 397 | type 398 | GDNativeInterface* {.bycopy.} = object 399 | version_major*: uint32 400 | version_minor*: uint32 401 | version_patch*: uint32 402 | version_string*: cstring ## GODOT CORE 403 | mem_alloc*: proc (p_bytes: csize_t): pointer {.cdecl.} 404 | mem_realloc*: proc (p_ptr: pointer; p_bytes: csize_t): pointer {.cdecl.} 405 | mem_free*: proc (p_ptr: pointer) {.cdecl.} 406 | print_error*: proc (p_description: cstring; p_function: cstring; p_file: cstring; 407 | p_line: int32) {.cdecl.} 408 | print_warning*: proc (p_description: cstring; p_function: cstring; 409 | p_file: cstring; p_line: int32) {.cdecl.} 410 | print_script_error*: proc (p_description: cstring; p_function: cstring; 411 | p_file: cstring; p_line: int32) {.cdecl.} 412 | get_native_struct_size*: proc (p_name: cstring): uint64 {.cdecl.} ## GODOT VARIANT 413 | ## variant general 414 | variant_new_copy*: proc (r_dest: GDNativeVariantPtr; p_src: GDNativeVariantPtr) {. 415 | cdecl.} 416 | variant_new_nil*: proc (r_dest: GDNativeVariantPtr) {.cdecl.} 417 | variant_destroy*: proc (p_self: GDNativeVariantPtr) {.cdecl.} ## variant type 418 | variant_call*: proc (p_self: GDNativeVariantPtr; 419 | p_method: GDNativeStringNamePtr; 420 | p_args: ptr GDNativeVariantPtr; 421 | p_argument_count: GDNativeInt; 422 | r_return: GDNativeVariantPtr; 423 | r_error: ptr GDNativeCallError) {.cdecl.} 424 | variant_call_static*: proc (p_type: GDNativeVariantType; 425 | p_method: GDNativeStringNamePtr; 426 | p_args: ptr GDNativeVariantPtr; 427 | p_argument_count: GDNativeInt; 428 | r_return: GDNativeVariantPtr; 429 | r_error: ptr GDNativeCallError) {.cdecl.} 430 | variant_evaluate*: proc (p_op: GDNativeVariantOperator; p_a: GDNativeVariantPtr; 431 | p_b: GDNativeVariantPtr; r_return: GDNativeVariantPtr; 432 | r_valid: ptr GDNativeBool) {.cdecl.} 433 | variant_set*: proc (p_self: GDNativeVariantPtr; p_key: GDNativeVariantPtr; 434 | p_value: GDNativeVariantPtr; r_valid: ptr GDNativeBool) {.cdecl.} 435 | variant_set_named*: proc (p_self: GDNativeVariantPtr; 436 | p_key: GDNativeStringNamePtr; 437 | p_value: GDNativeVariantPtr; r_valid: ptr GDNativeBool) {. 438 | cdecl.} 439 | variant_set_keyed*: proc (p_self: GDNativeVariantPtr; p_key: GDNativeVariantPtr; 440 | p_value: GDNativeVariantPtr; r_valid: ptr GDNativeBool) {. 441 | cdecl.} 442 | variant_set_indexed*: proc (p_self: GDNativeVariantPtr; p_index: GDNativeInt; 443 | p_value: GDNativeVariantPtr; 444 | r_valid: ptr GDNativeBool; r_oob: ptr GDNativeBool) {. 445 | cdecl.} 446 | variant_get*: proc (p_self: GDNativeVariantPtr; p_key: GDNativeVariantPtr; 447 | r_ret: GDNativeVariantPtr; r_valid: ptr GDNativeBool) {.cdecl.} 448 | variant_get_named*: proc (p_self: GDNativeVariantPtr; 449 | p_key: GDNativeStringNamePtr; 450 | r_ret: GDNativeVariantPtr; r_valid: ptr GDNativeBool) {. 451 | cdecl.} 452 | variant_get_keyed*: proc (p_self: GDNativeVariantPtr; p_key: GDNativeVariantPtr; 453 | r_ret: GDNativeVariantPtr; r_valid: ptr GDNativeBool) {. 454 | cdecl.} 455 | variant_get_indexed*: proc (p_self: GDNativeVariantPtr; p_index: GDNativeInt; 456 | r_ret: GDNativeVariantPtr; 457 | r_valid: ptr GDNativeBool; r_oob: ptr GDNativeBool) {. 458 | cdecl.} 459 | variant_iter_init*: proc (p_self: GDNativeVariantPtr; 460 | r_iter: GDNativeVariantPtr; r_valid: ptr GDNativeBool): GDNativeBool {. 461 | cdecl.} 462 | variant_iter_next*: proc (p_self: GDNativeVariantPtr; 463 | r_iter: GDNativeVariantPtr; r_valid: ptr GDNativeBool): GDNativeBool {. 464 | cdecl.} 465 | variant_iter_get*: proc (p_self: GDNativeVariantPtr; r_iter: GDNativeVariantPtr; 466 | r_ret: GDNativeVariantPtr; r_valid: ptr GDNativeBool) {. 467 | cdecl.} 468 | variant_hash*: proc (p_self: GDNativeVariantPtr): GDNativeInt {.cdecl.} 469 | variant_recursive_hash*: proc (p_self: GDNativeVariantPtr; 470 | p_recursion_count: GDNativeInt): GDNativeInt {. 471 | cdecl.} 472 | variant_hash_compare*: proc (p_self: GDNativeVariantPtr; 473 | p_other: GDNativeVariantPtr): GDNativeBool {.cdecl.} 474 | variant_booleanize*: proc (p_self: GDNativeVariantPtr): GDNativeBool {.cdecl.} 475 | variant_sub*: proc (p_a: GDNativeVariantPtr; p_b: GDNativeVariantPtr; 476 | r_dst: GDNativeVariantPtr) {.cdecl.} 477 | variant_blend*: proc (p_a: GDNativeVariantPtr; p_b: GDNativeVariantPtr; 478 | p_c: cfloat; r_dst: GDNativeVariantPtr) {.cdecl.} 479 | variant_interpolate*: proc (p_a: GDNativeVariantPtr; p_b: GDNativeVariantPtr; 480 | p_c: cfloat; r_dst: GDNativeVariantPtr) {.cdecl.} 481 | variant_duplicate*: proc (p_self: GDNativeVariantPtr; r_ret: GDNativeVariantPtr; 482 | p_deep: GDNativeBool) {.cdecl.} 483 | variant_stringify*: proc (p_self: GDNativeVariantPtr; r_ret: GDNativeStringPtr) {. 484 | cdecl.} 485 | variant_get_type*: proc (p_self: GDNativeVariantPtr): GDNativeVariantType {.cdecl.} 486 | variant_has_method*: proc (p_self: GDNativeVariantPtr; 487 | p_method: GDNativeStringNamePtr): GDNativeBool {.cdecl.} 488 | variant_has_member*: proc (p_type: GDNativeVariantType; 489 | p_member: GDNativeStringNamePtr): GDNativeBool {.cdecl.} 490 | variant_has_key*: proc (p_self: GDNativeVariantPtr; p_key: GDNativeVariantPtr; 491 | r_valid: ptr GDNativeBool): GDNativeBool {.cdecl.} 492 | variant_get_type_name*: proc (p_type: GDNativeVariantType; 493 | r_name: GDNativeStringPtr) {.cdecl.} 494 | variant_can_convert*: proc (p_from: GDNativeVariantType; 495 | p_to: GDNativeVariantType): GDNativeBool {.cdecl.} 496 | variant_can_convert_strict*: proc (p_from: GDNativeVariantType; 497 | p_to: GDNativeVariantType): GDNativeBool {. 498 | cdecl.} ## ptrcalls 499 | get_variant_from_type_constructor*: proc (p_type: GDNativeVariantType): GDNativeVariantFromTypeConstructorFunc {. 500 | cdecl.} 501 | get_variant_to_type_constructor*: proc (p_type: GDNativeVariantType): GDNativeTypeFromVariantConstructorFunc {. 502 | cdecl.} 503 | variant_get_ptr_operator_evaluator*: proc ( 504 | p_operator: GDNativeVariantOperator; p_type_a: GDNativeVariantType; 505 | p_type_b: GDNativeVariantType): GDNativePtrOperatorEvaluator {.cdecl.} 506 | variant_get_ptr_builtin_method*: proc (p_type: GDNativeVariantType; 507 | p_method: cstring; p_hash: GDNativeInt): GDNativePtrBuiltInMethod {.cdecl.} 508 | variant_get_ptr_constructor*: proc (p_type: GDNativeVariantType; 509 | p_constructor: int32): GDNativePtrConstructor {. 510 | cdecl.} 511 | variant_get_ptr_destructor*: proc (p_type: GDNativeVariantType): GDNativePtrDestructor {. 512 | cdecl.} 513 | variant_construct*: proc (p_type: GDNativeVariantType; 514 | p_base: GDNativeVariantPtr; 515 | p_args: ptr GDNativeVariantPtr; 516 | p_argument_count: int32; 517 | r_error: ptr GDNativeCallError) {.cdecl.} 518 | variant_get_ptr_setter*: proc (p_type: GDNativeVariantType; p_member: cstring): GDNativePtrSetter {. 519 | cdecl.} 520 | variant_get_ptr_getter*: proc (p_type: GDNativeVariantType; p_member: cstring): GDNativePtrGetter {. 521 | cdecl.} 522 | variant_get_ptr_indexed_setter*: proc (p_type: GDNativeVariantType): GDNativePtrIndexedSetter {. 523 | cdecl.} 524 | variant_get_ptr_indexed_getter*: proc (p_type: GDNativeVariantType): GDNativePtrIndexedGetter {. 525 | cdecl.} 526 | variant_get_ptr_keyed_setter*: proc (p_type: GDNativeVariantType): GDNativePtrKeyedSetter {. 527 | cdecl.} 528 | variant_get_ptr_keyed_getter*: proc (p_type: GDNativeVariantType): GDNativePtrKeyedGetter {. 529 | cdecl.} 530 | variant_get_ptr_keyed_checker*: proc (p_type: GDNativeVariantType): GDNativePtrKeyedChecker {. 531 | cdecl.} 532 | variant_get_constant_value*: proc (p_type: GDNativeVariantType; 533 | p_constant: cstring; 534 | r_ret: GDNativeVariantPtr) {.cdecl.} 535 | variant_get_ptr_utility_function*: proc (p_function: cstring; 536 | p_hash: GDNativeInt): GDNativePtrUtilityFunction {.cdecl.} ## extra utilities 537 | string_new_with_latin1_chars*: proc (r_dest: GDNativeStringPtr; 538 | p_contents: cstring) {.cdecl.} 539 | string_new_with_utf8_chars*: proc (r_dest: GDNativeStringPtr; 540 | p_contents: cstring) {.cdecl.} 541 | string_new_with_utf16_chars*: proc (r_dest: GDNativeStringPtr; 542 | p_contents: ptr char16_t) {.cdecl.} 543 | string_new_with_utf32_chars*: proc (r_dest: GDNativeStringPtr; 544 | p_contents: ptr char32_t) {.cdecl.} 545 | string_new_with_wide_chars*: proc (r_dest: GDNativeStringPtr; 546 | p_contents: ptr uint32) {.cdecl.} 547 | string_new_with_latin1_chars_and_len*: proc (r_dest: GDNativeStringPtr; 548 | p_contents: cstring; p_size: GDNativeInt) {.cdecl.} 549 | string_new_with_utf8_chars_and_len*: proc (r_dest: GDNativeStringPtr; 550 | p_contents: cstring; p_size: GDNativeInt) {.cdecl.} 551 | string_new_with_utf16_chars_and_len*: proc (r_dest: GDNativeStringPtr; 552 | p_contents: ptr char16_t; p_size: GDNativeInt) {.cdecl.} 553 | string_new_with_utf32_chars_and_len*: proc (r_dest: GDNativeStringPtr; 554 | p_contents: ptr char32_t; p_size: GDNativeInt) {.cdecl.} 555 | string_new_with_wide_chars_and_len*: proc (r_dest: GDNativeStringPtr; 556 | p_contents: ptr uint32; p_size: GDNativeInt) {.cdecl.} ## Information about the following functions: 557 | ## - The return value is the resulting encoded string length. 558 | ## - The length returned is in characters, not in bytes. It also does not include a trailing zero. 559 | ## - These functions also do not write trailing zero, If you need it, write it yourself at the position indicated by the length (and make sure to allocate it). 560 | ## - Passing NULL in r_text means only the length is computed (again, without including trailing zero). 561 | ## - p_max_write_length argument is in characters, not bytes. It will be ignored if r_text is NULL. 562 | ## - p_max_write_length argument does not affect the return value, it's only to cap write length. 563 | ## 564 | string_to_latin1_chars*: proc (p_self: GDNativeStringPtr; r_text: cstring; 565 | p_max_write_length: GDNativeInt): GDNativeInt {. 566 | cdecl.} 567 | string_to_utf8_chars*: proc (p_self: GDNativeStringPtr; r_text: cstring; 568 | p_max_write_length: GDNativeInt): GDNativeInt {. 569 | cdecl.} 570 | string_to_utf16_chars*: proc (p_self: GDNativeStringPtr; r_text: ptr char16_t; 571 | p_max_write_length: GDNativeInt): GDNativeInt {. 572 | cdecl.} 573 | string_to_utf32_chars*: proc (p_self: GDNativeStringPtr; r_text: ptr char32_t; 574 | p_max_write_length: GDNativeInt): GDNativeInt {. 575 | cdecl.} 576 | string_to_wide_chars*: proc (p_self: GDNativeStringPtr; r_text: ptr uint32; 577 | p_max_write_length: GDNativeInt): GDNativeInt {. 578 | cdecl.} 579 | string_operator_index*: proc (p_self: GDNativeStringPtr; p_index: GDNativeInt): ptr char32_t {. 580 | cdecl.} 581 | string_operator_index_const*: proc (p_self: GDNativeStringPtr; 582 | p_index: GDNativeInt): ptr char32_t {.cdecl.} ## Packed array functions 583 | packed_byte_array_operator_index*: proc (p_self: GDNativeTypePtr; 584 | p_index: GDNativeInt): ptr uint8 {.cdecl.} ## p_self should be a PackedByteArray 585 | packed_byte_array_operator_index_const*: proc (p_self: GDNativeTypePtr; 586 | p_index: GDNativeInt): ptr uint8 {.cdecl.} ## p_self should be a PackedByteArray 587 | packed_color_array_operator_index*: proc (p_self: GDNativeTypePtr; 588 | p_index: GDNativeInt): GDNativeTypePtr {.cdecl.} ## p_self should be a PackedColorArray, returns Color ptr 589 | packed_color_array_operator_index_const*: proc (p_self: GDNativeTypePtr; 590 | p_index: GDNativeInt): GDNativeTypePtr {.cdecl.} ## p_self should be a PackedColorArray, returns Color ptr 591 | packed_float32_array_operator_index*: proc (p_self: GDNativeTypePtr; 592 | p_index: GDNativeInt): ptr cfloat {.cdecl.} ## p_self should be a PackedFloat32Array 593 | packed_float32_array_operator_index_const*: proc (p_self: GDNativeTypePtr; 594 | p_index: GDNativeInt): ptr cfloat {.cdecl.} ## p_self should be a PackedFloat32Array 595 | packed_float64_array_operator_index*: proc (p_self: GDNativeTypePtr; 596 | p_index: GDNativeInt): ptr cdouble {.cdecl.} ## p_self should be a PackedFloat64Array 597 | packed_float64_array_operator_index_const*: proc (p_self: GDNativeTypePtr; 598 | p_index: GDNativeInt): ptr cdouble {.cdecl.} ## p_self should be a PackedFloat64Array 599 | packed_int32_array_operator_index*: proc (p_self: GDNativeTypePtr; 600 | p_index: GDNativeInt): ptr int32 {.cdecl.} ## p_self should be a PackedInt32Array 601 | packed_int32_array_operator_index_const*: proc (p_self: GDNativeTypePtr; 602 | p_index: GDNativeInt): ptr int32 {.cdecl.} ## p_self should be a PackedInt32Array 603 | packed_int64_array_operator_index*: proc (p_self: GDNativeTypePtr; 604 | p_index: GDNativeInt): ptr int64 {.cdecl.} ## p_self should be a PackedInt32Array 605 | packed_int64_array_operator_index_const*: proc (p_self: GDNativeTypePtr; 606 | p_index: GDNativeInt): ptr int64 {.cdecl.} ## p_self should be a PackedInt32Array 607 | packed_string_array_operator_index*: proc (p_self: GDNativeTypePtr; 608 | p_index: GDNativeInt): GDNativeStringPtr {.cdecl.} ## p_self should be a PackedStringArray 609 | packed_string_array_operator_index_const*: proc (p_self: GDNativeTypePtr; 610 | p_index: GDNativeInt): GDNativeStringPtr {.cdecl.} ## p_self should be a PackedStringArray 611 | packed_vector2_array_operator_index*: proc (p_self: GDNativeTypePtr; 612 | p_index: GDNativeInt): GDNativeTypePtr {.cdecl.} ## p_self should be a PackedVector2Array, returns Vector2 ptr 613 | packed_vector2_array_operator_index_const*: proc (p_self: GDNativeTypePtr; 614 | p_index: GDNativeInt): GDNativeTypePtr {.cdecl.} ## p_self should be a PackedVector2Array, returns Vector2 ptr 615 | packed_vector3_array_operator_index*: proc (p_self: GDNativeTypePtr; 616 | p_index: GDNativeInt): GDNativeTypePtr {.cdecl.} ## p_self should be a PackedVector3Array, returns Vector3 ptr 617 | packed_vector3_array_operator_index_const*: proc (p_self: GDNativeTypePtr; 618 | p_index: GDNativeInt): GDNativeTypePtr {.cdecl.} ## p_self should be a PackedVector3Array, returns Vector3 ptr 619 | array_operator_index*: proc (p_self: GDNativeTypePtr; p_index: GDNativeInt): GDNativeVariantPtr {. 620 | cdecl.} ## p_self should be an Array ptr 621 | array_operator_index_const*: proc (p_self: GDNativeTypePtr; p_index: GDNativeInt): GDNativeVariantPtr {. 622 | cdecl.} ## p_self should be an Array ptr 623 | ## Dictionary functions 624 | dictionary_operator_index*: proc (p_self: GDNativeTypePtr; 625 | p_key: GDNativeVariantPtr): GDNativeVariantPtr {. 626 | cdecl.} ## p_self should be an Dictionary ptr 627 | dictionary_operator_index_const*: proc (p_self: GDNativeTypePtr; 628 | p_key: GDNativeVariantPtr): GDNativeVariantPtr {.cdecl.} ## p_self should be an Dictionary ptr 629 | ## OBJECT 630 | object_method_bind_call*: proc (p_method_bind: GDNativeMethodBindPtr; 631 | p_instance: GDNativeObjectPtr; 632 | p_args: ptr GDNativeVariantPtr; 633 | p_arg_count: GDNativeInt; 634 | r_ret: GDNativeVariantPtr; 635 | r_error: ptr GDNativeCallError) {.cdecl.} 636 | object_method_bind_ptrcall*: proc (p_method_bind: GDNativeMethodBindPtr; 637 | p_instance: GDNativeObjectPtr; 638 | p_args: ptr GDNativeTypePtr; 639 | r_ret: GDNativeTypePtr) {.cdecl.} 640 | object_destroy*: proc (p_o: GDNativeObjectPtr) {.cdecl.} 641 | global_get_singleton*: proc (p_name: cstring): GDNativeObjectPtr {.cdecl.} 642 | object_get_instance_binding*: proc (p_o: GDNativeObjectPtr; p_token: pointer; 643 | p_callbacks: ptr GDNativeInstanceBindingCallbacks): pointer {.cdecl.} 644 | object_set_instance_binding*: proc (p_o: GDNativeObjectPtr; p_token: pointer; 645 | p_binding: pointer; p_callbacks: ptr GDNativeInstanceBindingCallbacks) {. 646 | cdecl.} 647 | object_set_instance*: proc (p_o: GDNativeObjectPtr; p_classname: cstring; 648 | p_instance: GDExtensionClassInstancePtr) {.cdecl.} ## p_classname should be a registered extension class and should extend the p_o object's class. 649 | object_cast_to*: proc (p_object: GDNativeObjectPtr; p_class_tag: pointer): GDNativeObjectPtr {. 650 | cdecl.} 651 | object_get_instance_from_id*: proc (p_instance_id: GDObjectInstanceID): GDNativeObjectPtr {. 652 | cdecl.} 653 | object_get_instance_id*: proc (p_object: GDNativeObjectPtr): GDObjectInstanceID {. 654 | cdecl.} ## SCRIPT INSTANCE 655 | script_instance_create*: proc (p_info: ptr GDNativeExtensionScriptInstanceInfo; 656 | p_instance_data: GDNativeExtensionScriptInstanceDataPtr): GDNativeScriptInstancePtr {. 657 | cdecl.} ## CLASSDB 658 | classdb_construct_object*: proc (p_classname: cstring): GDNativeObjectPtr {.cdecl.} ## The passed class must be a built-in godot class, or an already-registered extension class. In both case, object_set_instance should be called to fully initialize the object. 659 | classdb_get_method_bind*: proc (p_classname: cstring; p_methodname: cstring; 660 | p_hash: GDNativeInt): GDNativeMethodBindPtr {. 661 | cdecl.} 662 | classdb_get_class_tag*: proc (p_classname: cstring): pointer {.cdecl.} ## CLASSDB EXTENSION 663 | classdb_register_extension_class*: proc ( 664 | p_library: GDNativeExtensionClassLibraryPtr; p_class_name: cstring; 665 | p_parent_class_name: cstring; 666 | p_extension_funcs: ptr GDNativeExtensionClassCreationInfo) {.cdecl.} 667 | classdb_register_extension_class_method*: proc ( 668 | p_library: GDNativeExtensionClassLibraryPtr; p_class_name: cstring; 669 | p_method_info: ptr GDNativeExtensionClassMethodInfo) {.cdecl.} 670 | classdb_register_extension_class_integer_constant*: proc ( 671 | p_library: GDNativeExtensionClassLibraryPtr; p_class_name: cstring; 672 | p_enum_name: cstring; p_constant_name: cstring; 673 | p_constant_value: GDNativeInt; p_is_bitfield: GDNativeBool) {.cdecl.} 674 | classdb_register_extension_class_property*: proc ( 675 | p_library: GDNativeExtensionClassLibraryPtr; p_class_name: cstring; 676 | p_info: ptr GDNativePropertyInfo; p_setter: cstring; p_getter: cstring) {.cdecl.} 677 | classdb_register_extension_class_property_group*: proc ( 678 | p_library: GDNativeExtensionClassLibraryPtr; p_class_name: cstring; 679 | p_group_name: cstring; p_prefix: cstring) {.cdecl.} 680 | classdb_register_extension_class_property_subgroup*: proc ( 681 | p_library: GDNativeExtensionClassLibraryPtr; p_class_name: cstring; 682 | p_subgroup_name: cstring; p_prefix: cstring) {.cdecl.} 683 | classdb_register_extension_class_signal*: proc ( 684 | p_library: GDNativeExtensionClassLibraryPtr; p_class_name: cstring; 685 | p_signal_name: cstring; p_argument_info: ptr GDNativePropertyInfo; 686 | p_argument_count: GDNativeInt) {.cdecl.} 687 | classdb_unregister_extension_class*: proc ( 688 | p_library: GDNativeExtensionClassLibraryPtr; p_class_name: cstring) {.cdecl.} ## Unregistering a parent class before a class that inherits it will result in failure. Inheritors must be unregistered first. 689 | get_library_path*: proc (p_library: GDNativeExtensionClassLibraryPtr; 690 | r_path: GDNativeStringPtr) {.cdecl.} 691 | 692 | 693 | ## INITIALIZATION 694 | 695 | type 696 | GDNativeInitializationLevel* = enum 697 | GDNATIVE_INITIALIZATION_CORE, GDNATIVE_INITIALIZATION_SERVERS, 698 | GDNATIVE_INITIALIZATION_SCENE, GDNATIVE_INITIALIZATION_EDITOR, 699 | GDNATIVE_MAX_INITIALIZATION_LEVEL 700 | GDNativeInitialization* {.bycopy.} = object 701 | minimum_initialization_level*: GDNativeInitializationLevel ## Minimum initialization level required. 702 | ## If Core or Servers, the extension needs editor or game restart to take effect 703 | ## Up to the user to supply when initializing 704 | userdata*: pointer ## This function will be called multiple times for each initialization level. 705 | initialize*: proc (userdata: pointer; p_level: GDNativeInitializationLevel) {. 706 | cdecl.} 707 | deinitialize*: proc (userdata: pointer; p_level: GDNativeInitializationLevel) {. 708 | cdecl.} 709 | 710 | 711 | 712 | ## Define a C function prototype that implements the function below and expose it to dlopen() (or similar). 713 | ## It will be called on initialization. The name must be an unique one specified in the .gdextension config file. 714 | ## 715 | 716 | type 717 | GDNativeInitializationFunction* = proc (p_interface: ptr GDNativeInterface; 718 | p_library: GDNativeExtensionClassLibraryPtr; r_initialization: ptr GDNativeInitialization): GDNativeBool {. 719 | cdecl.} 720 | -------------------------------------------------------------------------------- /src/gdextension_nim/wrapped_header/gdnative_interface.nim: -------------------------------------------------------------------------------- 1 | ## *********************************************************************** 2 | ## gdnative_interface.h 3 | ## *********************************************************************** 4 | ## This file is part of: 5 | ## GODOT ENGINE 6 | ## https://godotengine.org 7 | ## *********************************************************************** 8 | ## Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. 9 | ## Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). 10 | ## 11 | ## Permission is hereby granted, free of charge, to any person obtaining 12 | ## a copy of this software and associated documentation files (the 13 | ## "Software"), to deal in the Software without restriction, including 14 | ## without limitation the rights to use, copy, modify, merge, publish, 15 | ## distribute, sublicense, and/or sell copies of the Software, and to 16 | ## permit persons to whom the Software is furnished to do so, subject to 17 | ## the following conditions: 18 | ## 19 | ## The above copyright notice and this permission notice shall be 20 | ## included in all copies or substantial portions of the Software. 21 | ## 22 | ## THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 23 | ## EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 24 | ## MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 25 | ## IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 26 | ## CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 27 | ## TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 28 | ## SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 29 | ## *********************************************************************** 30 | 31 | ## This is a C class header, you can copy it and use it directly in your own binders. 32 | ## Together with the JSON file, you should be able to generate any binder. 33 | ## 34 | 35 | type 36 | char32_t* = uint32 37 | char16_t* = uint16 38 | 39 | ## VARIANT TYPES 40 | 41 | type ## comparison 42 | GDNativeVariantType* = enum 43 | GDNATIVE_VARIANT_TYPE_NIL, ## atomic types 44 | GDNATIVE_VARIANT_TYPE_BOOL, GDNATIVE_VARIANT_TYPE_INT, 45 | GDNATIVE_VARIANT_TYPE_FLOAT, GDNATIVE_VARIANT_TYPE_STRING, ## math types 46 | GDNATIVE_VARIANT_TYPE_VECTOR2, GDNATIVE_VARIANT_TYPE_VECTOR2I, 47 | GDNATIVE_VARIANT_TYPE_RECT2, GDNATIVE_VARIANT_TYPE_RECT2I, 48 | GDNATIVE_VARIANT_TYPE_VECTOR3, GDNATIVE_VARIANT_TYPE_VECTOR3I, 49 | GDNATIVE_VARIANT_TYPE_TRANSFORM2D, GDNATIVE_VARIANT_TYPE_VECTOR4, 50 | GDNATIVE_VARIANT_TYPE_VECTOR4I, GDNATIVE_VARIANT_TYPE_PLANE, 51 | GDNATIVE_VARIANT_TYPE_QUATERNION, GDNATIVE_VARIANT_TYPE_AABB, 52 | GDNATIVE_VARIANT_TYPE_BASIS, GDNATIVE_VARIANT_TYPE_TRANSFORM3D, GDNATIVE_VARIANT_TYPE_PROJECTION, ## misc types 53 | GDNATIVE_VARIANT_TYPE_COLOR, GDNATIVE_VARIANT_TYPE_STRING_NAME, 54 | GDNATIVE_VARIANT_TYPE_NODE_PATH, GDNATIVE_VARIANT_TYPE_RID, 55 | GDNATIVE_VARIANT_TYPE_OBJECT, GDNATIVE_VARIANT_TYPE_CALLABLE, 56 | GDNATIVE_VARIANT_TYPE_SIGNAL, GDNATIVE_VARIANT_TYPE_DICTIONARY, GDNATIVE_VARIANT_TYPE_ARRAY, ## typed arrays 57 | GDNATIVE_VARIANT_TYPE_PACKED_BYTE_ARRAY, 58 | GDNATIVE_VARIANT_TYPE_PACKED_INT32_ARRAY, 59 | GDNATIVE_VARIANT_TYPE_PACKED_INT64_ARRAY, 60 | GDNATIVE_VARIANT_TYPE_PACKED_FLOAT32_ARRAY, 61 | GDNATIVE_VARIANT_TYPE_PACKED_FLOAT64_ARRAY, 62 | GDNATIVE_VARIANT_TYPE_PACKED_STRING_ARRAY, 63 | GDNATIVE_VARIANT_TYPE_PACKED_VECTOR2_ARRAY, 64 | GDNATIVE_VARIANT_TYPE_PACKED_VECTOR3_ARRAY, 65 | GDNATIVE_VARIANT_TYPE_PACKED_COLOR_ARRAY, GDNATIVE_VARIANT_TYPE_VARIANT_MAX 66 | GDNativeVariantOperator* = enum 67 | GDNATIVE_VARIANT_OP_EQUAL, GDNATIVE_VARIANT_OP_NOT_EQUAL, 68 | GDNATIVE_VARIANT_OP_LESS, GDNATIVE_VARIANT_OP_LESS_EQUAL, 69 | GDNATIVE_VARIANT_OP_GREATER, GDNATIVE_VARIANT_OP_GREATER_EQUAL, ## mathematic 70 | GDNATIVE_VARIANT_OP_ADD, GDNATIVE_VARIANT_OP_SUBTRACT, 71 | GDNATIVE_VARIANT_OP_MULTIPLY, GDNATIVE_VARIANT_OP_DIVIDE, 72 | GDNATIVE_VARIANT_OP_NEGATE, GDNATIVE_VARIANT_OP_POSITIVE, 73 | GDNATIVE_VARIANT_OP_MODULE, GDNATIVE_VARIANT_OP_POWER, ## bitwise 74 | GDNATIVE_VARIANT_OP_SHIFT_LEFT, GDNATIVE_VARIANT_OP_SHIFT_RIGHT, 75 | GDNATIVE_VARIANT_OP_BIT_AND, GDNATIVE_VARIANT_OP_BIT_OR, 76 | GDNATIVE_VARIANT_OP_BIT_XOR, GDNATIVE_VARIANT_OP_BIT_NEGATE, ## logic 77 | GDNATIVE_VARIANT_OP_AND, GDNATIVE_VARIANT_OP_OR, GDNATIVE_VARIANT_OP_XOR, GDNATIVE_VARIANT_OP_NOT, ## containment 78 | GDNATIVE_VARIANT_OP_IN, GDNATIVE_VARIANT_OP_MAX 79 | GDNativeVariantPtr* = pointer 80 | GDNativeStringNamePtr* = pointer 81 | GDNativeStringPtr* = pointer 82 | GDNativeObjectPtr* = pointer 83 | GDNativeTypePtr* = pointer 84 | GDNativeExtensionPtr* = pointer 85 | GDNativeMethodBindPtr* = pointer 86 | GDNativeInt* = int64 87 | GDNativeBool* = uint8 88 | GDObjectInstanceID* = uint64 89 | 90 | 91 | 92 | ## VARIANT DATA I/O 93 | 94 | type 95 | GDNativeCallErrorType* = enum 96 | GDNATIVE_CALL_OK, GDNATIVE_CALL_ERROR_INVALID_METHOD, GDNATIVE_CALL_ERROR_INVALID_ARGUMENT, ## expected is variant type 97 | GDNATIVE_CALL_ERROR_TOO_MANY_ARGUMENTS, ## expected is number of arguments 98 | GDNATIVE_CALL_ERROR_TOO_FEW_ARGUMENTS, ## expected is number of arguments 99 | GDNATIVE_CALL_ERROR_INSTANCE_IS_NULL, GDNATIVE_CALL_ERROR_METHOD_NOT_CONST ## used for const call 100 | GDNativeCallError* {.bycopy.} = object 101 | error*: GDNativeCallErrorType 102 | argument*: int32 103 | expected*: int32 104 | 105 | GDNativeVariantFromTypeConstructorFunc* = proc (a1: GDNativeVariantPtr; 106 | a2: GDNativeTypePtr) {.cdecl.} 107 | GDNativeTypeFromVariantConstructorFunc* = proc (a1: GDNativeTypePtr; 108 | a2: GDNativeVariantPtr) {.cdecl.} 109 | GDNativePtrOperatorEvaluator* = proc (p_left: GDNativeTypePtr; 110 | p_right: GDNativeTypePtr; 111 | r_result: GDNativeTypePtr) {.cdecl.} 112 | GDNativePtrBuiltInMethod* = proc (p_base: GDNativeTypePtr; 113 | p_args: ptr GDNativeTypePtr; 114 | r_return: GDNativeTypePtr; p_argument_count: cint) {. 115 | cdecl.} 116 | GDNativePtrConstructor* = proc (p_base: GDNativeTypePtr; 117 | p_args: ptr GDNativeTypePtr) {.cdecl.} 118 | GDNativePtrDestructor* = proc (p_base: GDNativeTypePtr) {.cdecl.} 119 | GDNativePtrSetter* = proc (p_base: GDNativeTypePtr; p_value: GDNativeTypePtr) {.cdecl.} 120 | GDNativePtrGetter* = proc (p_base: GDNativeTypePtr; r_value: GDNativeTypePtr) {.cdecl.} 121 | GDNativePtrIndexedSetter* = proc (p_base: GDNativeTypePtr; p_index: GDNativeInt; 122 | p_value: GDNativeTypePtr) {.cdecl.} 123 | GDNativePtrIndexedGetter* = proc (p_base: GDNativeTypePtr; p_index: GDNativeInt; 124 | r_value: GDNativeTypePtr) {.cdecl.} 125 | GDNativePtrKeyedSetter* = proc (p_base: GDNativeTypePtr; p_key: GDNativeTypePtr; 126 | p_value: GDNativeTypePtr) {.cdecl.} 127 | GDNativePtrKeyedGetter* = proc (p_base: GDNativeTypePtr; p_key: GDNativeTypePtr; 128 | r_value: GDNativeTypePtr) {.cdecl.} 129 | GDNativePtrKeyedChecker* = proc (p_base: GDNativeVariantPtr; 130 | p_key: GDNativeVariantPtr): uint32 {.cdecl.} 131 | GDNativePtrUtilityFunction* = proc (r_return: GDNativeTypePtr; 132 | p_arguments: ptr GDNativeTypePtr; 133 | p_argument_count: cint) {.cdecl.} 134 | GDNativeClassConstructor* = proc (): GDNativeObjectPtr {.cdecl.} 135 | GDNativeInstanceBindingCreateCallback* = proc (p_token: pointer; 136 | p_instance: pointer): pointer {.cdecl.} 137 | GDNativeInstanceBindingFreeCallback* = proc (p_token: pointer; p_instance: pointer; 138 | p_binding: pointer) {.cdecl.} 139 | GDNativeInstanceBindingReferenceCallback* = proc (p_token: pointer; 140 | p_binding: pointer; p_reference: GDNativeBool): GDNativeBool {.cdecl.} 141 | GDNativeInstanceBindingCallbacks* {.bycopy.} = object 142 | create_callback*: GDNativeInstanceBindingCreateCallback 143 | free_callback*: GDNativeInstanceBindingFreeCallback 144 | reference_callback*: GDNativeInstanceBindingReferenceCallback 145 | 146 | 147 | 148 | ## EXTENSION CLASSES 149 | 150 | type 151 | GDExtensionClassInstancePtr* = pointer 152 | GDNativeExtensionClassSet* = proc (p_instance: GDExtensionClassInstancePtr; 153 | p_name: GDNativeStringNamePtr; 154 | p_value: GDNativeVariantPtr): GDNativeBool {. 155 | cdecl.} 156 | GDNativeExtensionClassGet* = proc (p_instance: GDExtensionClassInstancePtr; 157 | p_name: GDNativeStringNamePtr; 158 | r_ret: GDNativeVariantPtr): GDNativeBool {.cdecl.} 159 | GDNativeExtensionClassGetRID* = proc (p_instance: GDExtensionClassInstancePtr): uint64 {. 160 | cdecl.} 161 | GDNativePropertyInfo* {.bycopy.} = object 162 | `type`*: uint32 163 | name*: cstring 164 | class_name*: cstring 165 | hint*: uint32 166 | hint_string*: cstring 167 | usage*: uint32 168 | 169 | GDNativeMethodInfo* {.bycopy.} = object 170 | name*: cstring 171 | return_value*: GDNativePropertyInfo 172 | flags*: uint32 ## From GDNativeExtensionClassMethodFlags 173 | id*: int32 174 | arguments*: ptr GDNativePropertyInfo 175 | argument_count*: uint32 176 | default_arguments*: GDNativeVariantPtr 177 | default_argument_count*: uint32 178 | 179 | GDNativeExtensionClassGetPropertyList* = proc ( 180 | p_instance: GDExtensionClassInstancePtr; r_count: ptr uint32): ptr GDNativePropertyInfo {. 181 | cdecl.} 182 | GDNativeExtensionClassFreePropertyList* = proc ( 183 | p_instance: GDExtensionClassInstancePtr; p_list: ptr GDNativePropertyInfo) {. 184 | cdecl.} 185 | GDNativeExtensionClassPropertyCanRevert* = proc ( 186 | p_instance: GDExtensionClassInstancePtr; p_name: GDNativeStringNamePtr): GDNativeBool {. 187 | cdecl.} 188 | GDNativeExtensionClassPropertyGetRevert* = proc ( 189 | p_instance: GDExtensionClassInstancePtr; p_name: GDNativeStringNamePtr; 190 | r_ret: GDNativeVariantPtr): GDNativeBool {.cdecl.} 191 | GDNativeExtensionClassNotification* = proc ( 192 | p_instance: GDExtensionClassInstancePtr; p_what: int32) {.cdecl.} 193 | GDNativeExtensionClassToString* = proc (p_instance: GDExtensionClassInstancePtr; 194 | p_out: GDNativeStringPtr) {.cdecl.} 195 | GDNativeExtensionClassReference* = proc (p_instance: GDExtensionClassInstancePtr) {. 196 | cdecl.} 197 | GDNativeExtensionClassUnreference* = proc ( 198 | p_instance: GDExtensionClassInstancePtr) {.cdecl.} 199 | GDNativeExtensionClassCallVirtual* = proc ( 200 | p_instance: GDExtensionClassInstancePtr; p_args: ptr GDNativeTypePtr; 201 | r_ret: GDNativeTypePtr) {.cdecl.} 202 | GDNativeExtensionClassCreateInstance* = proc (p_userdata: pointer): GDNativeObjectPtr {. 203 | cdecl.} 204 | GDNativeExtensionClassFreeInstance* = proc (p_userdata: pointer; 205 | p_instance: GDExtensionClassInstancePtr) {.cdecl.} 206 | GDNativeExtensionClassObjectInstance* = proc ( 207 | p_instance: GDExtensionClassInstancePtr; 208 | p_object_instance: GDNativeObjectPtr) {.cdecl.} 209 | GDNativeExtensionClassGetVirtual* = proc (p_userdata: pointer; p_name: cstring): GDNativeExtensionClassCallVirtual {. 210 | cdecl.} 211 | GDNativeExtensionClassCreationInfo* {.bycopy.} = object 212 | set_func*: GDNativeExtensionClassSet 213 | get_func*: GDNativeExtensionClassGet 214 | get_property_list_func*: GDNativeExtensionClassGetPropertyList 215 | free_property_list_func*: GDNativeExtensionClassFreePropertyList 216 | property_can_revert_func*: GDNativeExtensionClassPropertyCanRevert 217 | property_get_revert_func*: GDNativeExtensionClassPropertyGetRevert 218 | notification_func*: GDNativeExtensionClassNotification 219 | to_string_func*: GDNativeExtensionClassToString 220 | reference_func*: GDNativeExtensionClassReference 221 | unreference_func*: GDNativeExtensionClassUnreference 222 | create_instance_func*: GDNativeExtensionClassCreateInstance ## this one is mandatory 223 | free_instance_func*: GDNativeExtensionClassFreeInstance ## this one is mandatory 224 | get_virtual_func*: GDNativeExtensionClassGetVirtual 225 | get_rid_func*: GDNativeExtensionClassGetRID 226 | class_userdata*: pointer 227 | 228 | GDNativeExtensionClassLibraryPtr* = pointer 229 | 230 | ## Method 231 | 232 | type 233 | GDNativeExtensionClassMethodFlags* = enum 234 | GDNATIVE_EXTENSION_METHOD_FLAG_NORMAL = 1, 235 | GDNATIVE_EXTENSION_METHOD_FLAG_EDITOR = 2, 236 | GDNATIVE_EXTENSION_METHOD_FLAG_CONST = 4, 237 | GDNATIVE_EXTENSION_METHOD_FLAG_VIRTUAL = 8, 238 | GDNATIVE_EXTENSION_METHOD_FLAG_VARARG = 16, 239 | GDNATIVE_EXTENSION_METHOD_FLAG_STATIC = 32 240 | GDNativeExtensionClassMethodArgumentMetadata* = enum 241 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_NONE, 242 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_INT8, 243 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_INT16, 244 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_INT32, 245 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_INT64, 246 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_UINT8, 247 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_UINT16, 248 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_UINT32, 249 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_UINT64, 250 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_REAL_IS_FLOAT, 251 | GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_REAL_IS_DOUBLE 252 | GDNativeExtensionClassMethodCall* = proc (method_userdata: pointer; 253 | p_instance: GDExtensionClassInstancePtr; p_args: ptr GDNativeVariantPtr; 254 | p_argument_count: GDNativeInt; r_return: GDNativeVariantPtr; 255 | r_error: ptr GDNativeCallError) {.cdecl.} 256 | GDNativeExtensionClassMethodPtrCall* = proc (method_userdata: pointer; 257 | p_instance: GDExtensionClassInstancePtr; p_args: ptr GDNativeTypePtr; 258 | r_ret: GDNativeTypePtr) {.cdecl.} 259 | 260 | const 261 | GDNATIVE_EXTENSION_METHOD_FLAGS_DEFAULT* = GDNATIVE_EXTENSION_METHOD_FLAG_NORMAL 262 | 263 | 264 | ## passing -1 as argument in the following functions refers to the return type 265 | 266 | type 267 | GDNativeExtensionClassMethodGetArgumentType* = proc (p_method_userdata: pointer; 268 | p_argument: int32): GDNativeVariantType {.cdecl.} 269 | GDNativeExtensionClassMethodGetArgumentInfo* = proc (p_method_userdata: pointer; 270 | p_argument: int32; r_info: ptr GDNativePropertyInfo) {.cdecl.} 271 | GDNativeExtensionClassMethodGetArgumentMetadata* = proc ( 272 | p_method_userdata: pointer; p_argument: int32): GDNativeExtensionClassMethodArgumentMetadata {. 273 | cdecl.} 274 | GDNativeExtensionClassMethodInfo* {.bycopy.} = object 275 | name*: cstring 276 | method_userdata*: pointer 277 | call_func*: GDNativeExtensionClassMethodCall 278 | ptrcall_func*: GDNativeExtensionClassMethodPtrCall 279 | method_flags*: uint32 ## GDNativeExtensionClassMethodFlags 280 | argument_count*: uint32 281 | has_return_value*: GDNativeBool 282 | get_argument_type_func*: GDNativeExtensionClassMethodGetArgumentType 283 | get_argument_info_func*: GDNativeExtensionClassMethodGetArgumentInfo ## name and hint information for the argument can be omitted in release builds. Class name should always be present if it applies. 284 | get_argument_metadata_func*: GDNativeExtensionClassMethodGetArgumentMetadata 285 | default_argument_count*: uint32 286 | default_arguments*: ptr GDNativeVariantPtr 287 | 288 | 289 | ## SCRIPT INSTANCE EXTENSION 290 | 291 | type 292 | GDNativeExtensionScriptInstanceDataPtr* = pointer 293 | 294 | ## Pointer to custom ScriptInstance native implementation 295 | 296 | type 297 | GDNativeExtensionScriptInstanceSet* = proc ( 298 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 299 | p_name: GDNativeStringNamePtr; p_value: GDNativeVariantPtr): GDNativeBool {. 300 | cdecl.} 301 | GDNativeExtensionScriptInstanceGet* = proc ( 302 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 303 | p_name: GDNativeStringNamePtr; r_ret: GDNativeVariantPtr): GDNativeBool {.cdecl.} 304 | GDNativeExtensionScriptInstanceGetPropertyList* = proc ( 305 | p_instance: GDNativeExtensionScriptInstanceDataPtr; r_count: ptr uint32): ptr GDNativePropertyInfo {. 306 | cdecl.} 307 | GDNativeExtensionScriptInstanceFreePropertyList* = proc ( 308 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 309 | p_list: ptr GDNativePropertyInfo) {.cdecl.} 310 | GDNativeExtensionScriptInstanceGetPropertyType* = proc ( 311 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 312 | p_name: GDNativeStringNamePtr; r_is_valid: ptr GDNativeBool): GDNativeVariantType {. 313 | cdecl.} 314 | GDNativeExtensionScriptInstancePropertyCanRevert* = proc ( 315 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 316 | p_name: GDNativeStringNamePtr): GDNativeBool {.cdecl.} 317 | GDNativeExtensionScriptInstancePropertyGetRevert* = proc ( 318 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 319 | p_name: GDNativeStringNamePtr; r_ret: GDNativeVariantPtr): GDNativeBool {.cdecl.} 320 | GDNativeExtensionScriptInstanceGetOwner* = proc ( 321 | p_instance: GDNativeExtensionScriptInstanceDataPtr): GDNativeObjectPtr {. 322 | cdecl.} 323 | GDNativeExtensionScriptInstancePropertyStateAdd* = proc ( 324 | p_name: GDNativeStringNamePtr; p_value: GDNativeVariantPtr; 325 | p_userdata: pointer) {.cdecl.} 326 | GDNativeExtensionScriptInstanceGetPropertyState* = proc ( 327 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 328 | p_add_func: GDNativeExtensionScriptInstancePropertyStateAdd; 329 | p_userdata: pointer) {.cdecl.} 330 | GDNativeExtensionScriptInstanceGetMethodList* = proc ( 331 | p_instance: GDNativeExtensionScriptInstanceDataPtr; r_count: ptr uint32): ptr GDNativeMethodInfo {. 332 | cdecl.} 333 | GDNativeExtensionScriptInstanceFreeMethodList* = proc ( 334 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 335 | p_list: ptr GDNativeMethodInfo) {.cdecl.} 336 | GDNativeExtensionScriptInstanceHasMethod* = proc ( 337 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 338 | p_name: GDNativeStringNamePtr): GDNativeBool {.cdecl.} 339 | GDNativeExtensionScriptInstanceCall* = proc ( 340 | p_self: GDNativeExtensionScriptInstanceDataPtr; 341 | p_method: GDNativeStringNamePtr; p_args: ptr GDNativeVariantPtr; 342 | p_argument_count: GDNativeInt; r_return: GDNativeVariantPtr; 343 | r_error: ptr GDNativeCallError) {.cdecl.} 344 | GDNativeExtensionScriptInstanceNotification* = proc ( 345 | p_instance: GDNativeExtensionScriptInstanceDataPtr; p_what: int32) {.cdecl.} 346 | GDNativeExtensionScriptInstanceToString* = proc ( 347 | p_instance: GDNativeExtensionScriptInstanceDataPtr; 348 | r_is_valid: ptr GDNativeBool): cstring {.cdecl.} 349 | GDNativeExtensionScriptInstanceRefCountIncremented* = proc ( 350 | p_instance: GDNativeExtensionScriptInstanceDataPtr) {.cdecl.} 351 | GDNativeExtensionScriptInstanceRefCountDecremented* = proc ( 352 | p_instance: GDNativeExtensionScriptInstanceDataPtr): GDNativeBool {.cdecl.} 353 | GDNativeExtensionScriptInstanceGetScript* = proc ( 354 | p_instance: GDNativeExtensionScriptInstanceDataPtr): GDNativeObjectPtr {. 355 | cdecl.} 356 | GDNativeExtensionScriptInstanceIsPlaceholder* = proc ( 357 | p_instance: GDNativeExtensionScriptInstanceDataPtr): GDNativeBool {.cdecl.} 358 | GDNativeExtensionScriptLanguagePtr* = pointer 359 | GDNativeExtensionScriptInstanceGetLanguage* = proc ( 360 | p_instance: GDNativeExtensionScriptInstanceDataPtr): GDNativeExtensionScriptLanguagePtr {. 361 | cdecl.} 362 | GDNativeExtensionScriptInstanceFree* = proc ( 363 | p_instance: GDNativeExtensionScriptInstanceDataPtr) {.cdecl.} 364 | GDNativeScriptInstancePtr* = pointer 365 | 366 | ## Pointer to ScriptInstance. 367 | 368 | type 369 | GDNativeExtensionScriptInstanceInfo* {.bycopy.} = object 370 | set_func*: GDNativeExtensionScriptInstanceSet 371 | get_func*: GDNativeExtensionScriptInstanceGet 372 | get_property_list_func*: GDNativeExtensionScriptInstanceGetPropertyList 373 | free_property_list_func*: GDNativeExtensionScriptInstanceFreePropertyList 374 | get_property_type_func*: GDNativeExtensionScriptInstanceGetPropertyType 375 | property_can_revert_func*: GDNativeExtensionScriptInstancePropertyCanRevert 376 | property_get_revert_func*: GDNativeExtensionScriptInstancePropertyGetRevert 377 | get_owner_func*: GDNativeExtensionScriptInstanceGetOwner 378 | get_property_state_func*: GDNativeExtensionScriptInstanceGetPropertyState 379 | get_method_list_func*: GDNativeExtensionScriptInstanceGetMethodList 380 | free_method_list_func*: GDNativeExtensionScriptInstanceFreeMethodList 381 | has_method_func*: GDNativeExtensionScriptInstanceHasMethod 382 | call_func*: GDNativeExtensionScriptInstanceCall 383 | notification_func*: GDNativeExtensionScriptInstanceNotification 384 | to_string_func*: GDNativeExtensionScriptInstanceToString 385 | refcount_incremented_func*: GDNativeExtensionScriptInstanceRefCountIncremented 386 | refcount_decremented_func*: GDNativeExtensionScriptInstanceRefCountDecremented 387 | get_script_func*: GDNativeExtensionScriptInstanceGetScript 388 | is_placeholder_func*: GDNativeExtensionScriptInstanceIsPlaceholder 389 | set_fallback_func*: GDNativeExtensionScriptInstanceSet 390 | get_fallback_func*: GDNativeExtensionScriptInstanceGet 391 | get_language_func*: GDNativeExtensionScriptInstanceGetLanguage 392 | free_func*: GDNativeExtensionScriptInstanceFree 393 | 394 | 395 | ## INTERFACE 396 | 397 | type 398 | GDNativeInterface* {.bycopy.} = object 399 | version_major*: uint32 400 | version_minor*: uint32 401 | version_patch*: uint32 402 | version_string*: cstring ## GODOT CORE 403 | mem_alloc*: proc (p_bytes: csize_t): pointer {.cdecl.} 404 | mem_realloc*: proc (p_ptr: pointer; p_bytes: csize_t): pointer {.cdecl.} 405 | mem_free*: proc (p_ptr: pointer) {.cdecl.} 406 | print_error*: proc (p_description: cstring; p_function: cstring; p_file: cstring; 407 | p_line: int32) {.cdecl.} 408 | print_warning*: proc (p_description: cstring; p_function: cstring; 409 | p_file: cstring; p_line: int32) {.cdecl.} 410 | print_script_error*: proc (p_description: cstring; p_function: cstring; 411 | p_file: cstring; p_line: int32) {.cdecl.} 412 | get_native_struct_size*: proc (p_name: cstring): uint64 {.cdecl.} ## GODOT VARIANT 413 | ## variant general 414 | variant_new_copy*: proc (r_dest: GDNativeVariantPtr; p_src: GDNativeVariantPtr) {. 415 | cdecl.} 416 | variant_new_nil*: proc (r_dest: GDNativeVariantPtr) {.cdecl.} 417 | variant_destroy*: proc (p_self: GDNativeVariantPtr) {.cdecl.} ## variant type 418 | variant_call*: proc (p_self: GDNativeVariantPtr; 419 | p_method: GDNativeStringNamePtr; 420 | p_args: ptr GDNativeVariantPtr; 421 | p_argument_count: GDNativeInt; 422 | r_return: GDNativeVariantPtr; 423 | r_error: ptr GDNativeCallError) {.cdecl.} 424 | variant_call_static*: proc (p_type: GDNativeVariantType; 425 | p_method: GDNativeStringNamePtr; 426 | p_args: ptr GDNativeVariantPtr; 427 | p_argument_count: GDNativeInt; 428 | r_return: GDNativeVariantPtr; 429 | r_error: ptr GDNativeCallError) {.cdecl.} 430 | variant_evaluate*: proc (p_op: GDNativeVariantOperator; p_a: GDNativeVariantPtr; 431 | p_b: GDNativeVariantPtr; r_return: GDNativeVariantPtr; 432 | r_valid: ptr GDNativeBool) {.cdecl.} 433 | variant_set*: proc (p_self: GDNativeVariantPtr; p_key: GDNativeVariantPtr; 434 | p_value: GDNativeVariantPtr; r_valid: ptr GDNativeBool) {.cdecl.} 435 | variant_set_named*: proc (p_self: GDNativeVariantPtr; 436 | p_key: GDNativeStringNamePtr; 437 | p_value: GDNativeVariantPtr; r_valid: ptr GDNativeBool) {. 438 | cdecl.} 439 | variant_set_keyed*: proc (p_self: GDNativeVariantPtr; p_key: GDNativeVariantPtr; 440 | p_value: GDNativeVariantPtr; r_valid: ptr GDNativeBool) {. 441 | cdecl.} 442 | variant_set_indexed*: proc (p_self: GDNativeVariantPtr; p_index: GDNativeInt; 443 | p_value: GDNativeVariantPtr; 444 | r_valid: ptr GDNativeBool; r_oob: ptr GDNativeBool) {. 445 | cdecl.} 446 | variant_get*: proc (p_self: GDNativeVariantPtr; p_key: GDNativeVariantPtr; 447 | r_ret: GDNativeVariantPtr; r_valid: ptr GDNativeBool) {.cdecl.} 448 | variant_get_named*: proc (p_self: GDNativeVariantPtr; 449 | p_key: GDNativeStringNamePtr; 450 | r_ret: GDNativeVariantPtr; r_valid: ptr GDNativeBool) {. 451 | cdecl.} 452 | variant_get_keyed*: proc (p_self: GDNativeVariantPtr; p_key: GDNativeVariantPtr; 453 | r_ret: GDNativeVariantPtr; r_valid: ptr GDNativeBool) {. 454 | cdecl.} 455 | variant_get_indexed*: proc (p_self: GDNativeVariantPtr; p_index: GDNativeInt; 456 | r_ret: GDNativeVariantPtr; 457 | r_valid: ptr GDNativeBool; r_oob: ptr GDNativeBool) {. 458 | cdecl.} 459 | variant_iter_init*: proc (p_self: GDNativeVariantPtr; 460 | r_iter: GDNativeVariantPtr; r_valid: ptr GDNativeBool): GDNativeBool {. 461 | cdecl.} 462 | variant_iter_next*: proc (p_self: GDNativeVariantPtr; 463 | r_iter: GDNativeVariantPtr; r_valid: ptr GDNativeBool): GDNativeBool {. 464 | cdecl.} 465 | variant_iter_get*: proc (p_self: GDNativeVariantPtr; r_iter: GDNativeVariantPtr; 466 | r_ret: GDNativeVariantPtr; r_valid: ptr GDNativeBool) {. 467 | cdecl.} 468 | variant_hash*: proc (p_self: GDNativeVariantPtr): GDNativeInt {.cdecl.} 469 | variant_recursive_hash*: proc (p_self: GDNativeVariantPtr; 470 | p_recursion_count: GDNativeInt): GDNativeInt {. 471 | cdecl.} 472 | variant_hash_compare*: proc (p_self: GDNativeVariantPtr; 473 | p_other: GDNativeVariantPtr): GDNativeBool {.cdecl.} 474 | variant_booleanize*: proc (p_self: GDNativeVariantPtr): GDNativeBool {.cdecl.} 475 | variant_sub*: proc (p_a: GDNativeVariantPtr; p_b: GDNativeVariantPtr; 476 | r_dst: GDNativeVariantPtr) {.cdecl.} 477 | variant_blend*: proc (p_a: GDNativeVariantPtr; p_b: GDNativeVariantPtr; 478 | p_c: cfloat; r_dst: GDNativeVariantPtr) {.cdecl.} 479 | variant_interpolate*: proc (p_a: GDNativeVariantPtr; p_b: GDNativeVariantPtr; 480 | p_c: cfloat; r_dst: GDNativeVariantPtr) {.cdecl.} 481 | variant_duplicate*: proc (p_self: GDNativeVariantPtr; r_ret: GDNativeVariantPtr; 482 | p_deep: GDNativeBool) {.cdecl.} 483 | variant_stringify*: proc (p_self: GDNativeVariantPtr; r_ret: GDNativeStringPtr) {. 484 | cdecl.} 485 | variant_get_type*: proc (p_self: GDNativeVariantPtr): GDNativeVariantType {.cdecl.} 486 | variant_has_method*: proc (p_self: GDNativeVariantPtr; 487 | p_method: GDNativeStringNamePtr): GDNativeBool {.cdecl.} 488 | variant_has_member*: proc (p_type: GDNativeVariantType; 489 | p_member: GDNativeStringNamePtr): GDNativeBool {.cdecl.} 490 | variant_has_key*: proc (p_self: GDNativeVariantPtr; p_key: GDNativeVariantPtr; 491 | r_valid: ptr GDNativeBool): GDNativeBool {.cdecl.} 492 | variant_get_type_name*: proc (p_type: GDNativeVariantType; 493 | r_name: GDNativeStringPtr) {.cdecl.} 494 | variant_can_convert*: proc (p_from: GDNativeVariantType; 495 | p_to: GDNativeVariantType): GDNativeBool {.cdecl.} 496 | variant_can_convert_strict*: proc (p_from: GDNativeVariantType; 497 | p_to: GDNativeVariantType): GDNativeBool {. 498 | cdecl.} ## ptrcalls 499 | get_variant_from_type_constructor*: proc (p_type: GDNativeVariantType): GDNativeVariantFromTypeConstructorFunc {. 500 | cdecl.} 501 | get_variant_to_type_constructor*: proc (p_type: GDNativeVariantType): GDNativeTypeFromVariantConstructorFunc {. 502 | cdecl.} 503 | variant_get_ptr_operator_evaluator*: proc ( 504 | p_operator: GDNativeVariantOperator; p_type_a: GDNativeVariantType; 505 | p_type_b: GDNativeVariantType): GDNativePtrOperatorEvaluator {.cdecl.} 506 | variant_get_ptr_builtin_method*: proc (p_type: GDNativeVariantType; 507 | p_method: cstring; p_hash: GDNativeInt): GDNativePtrBuiltInMethod {.cdecl.} 508 | variant_get_ptr_constructor*: proc (p_type: GDNativeVariantType; 509 | p_constructor: int32): GDNativePtrConstructor {. 510 | cdecl.} 511 | variant_get_ptr_destructor*: proc (p_type: GDNativeVariantType): GDNativePtrDestructor {. 512 | cdecl.} 513 | variant_construct*: proc (p_type: GDNativeVariantType; 514 | p_base: GDNativeVariantPtr; 515 | p_args: ptr GDNativeVariantPtr; 516 | p_argument_count: int32; 517 | r_error: ptr GDNativeCallError) {.cdecl.} 518 | variant_get_ptr_setter*: proc (p_type: GDNativeVariantType; p_member: cstring): GDNativePtrSetter {. 519 | cdecl.} 520 | variant_get_ptr_getter*: proc (p_type: GDNativeVariantType; p_member: cstring): GDNativePtrGetter {. 521 | cdecl.} 522 | variant_get_ptr_indexed_setter*: proc (p_type: GDNativeVariantType): GDNativePtrIndexedSetter {. 523 | cdecl.} 524 | variant_get_ptr_indexed_getter*: proc (p_type: GDNativeVariantType): GDNativePtrIndexedGetter {. 525 | cdecl.} 526 | variant_get_ptr_keyed_setter*: proc (p_type: GDNativeVariantType): GDNativePtrKeyedSetter {. 527 | cdecl.} 528 | variant_get_ptr_keyed_getter*: proc (p_type: GDNativeVariantType): GDNativePtrKeyedGetter {. 529 | cdecl.} 530 | variant_get_ptr_keyed_checker*: proc (p_type: GDNativeVariantType): GDNativePtrKeyedChecker {. 531 | cdecl.} 532 | variant_get_constant_value*: proc (p_type: GDNativeVariantType; 533 | p_constant: cstring; 534 | r_ret: GDNativeVariantPtr) {.cdecl.} 535 | variant_get_ptr_utility_function*: proc (p_function: cstring; 536 | p_hash: GDNativeInt): GDNativePtrUtilityFunction {.cdecl.} ## extra utilities 537 | string_new_with_latin1_chars*: proc (r_dest: GDNativeStringPtr; 538 | p_contents: cstring) {.cdecl.} 539 | string_new_with_utf8_chars*: proc (r_dest: GDNativeStringPtr; 540 | p_contents: cstring) {.cdecl.} 541 | string_new_with_utf16_chars*: proc (r_dest: GDNativeStringPtr; 542 | p_contents: ptr char16_t) {.cdecl.} 543 | string_new_with_utf32_chars*: proc (r_dest: GDNativeStringPtr; 544 | p_contents: ptr char32_t) {.cdecl.} 545 | string_new_with_wide_chars*: proc (r_dest: GDNativeStringPtr; 546 | p_contents: ptr uint32) {.cdecl.} 547 | string_new_with_latin1_chars_and_len*: proc (r_dest: GDNativeStringPtr; 548 | p_contents: cstring; p_size: GDNativeInt) {.cdecl.} 549 | string_new_with_utf8_chars_and_len*: proc (r_dest: GDNativeStringPtr; 550 | p_contents: cstring; p_size: GDNativeInt) {.cdecl.} 551 | string_new_with_utf16_chars_and_len*: proc (r_dest: GDNativeStringPtr; 552 | p_contents: ptr char16_t; p_size: GDNativeInt) {.cdecl.} 553 | string_new_with_utf32_chars_and_len*: proc (r_dest: GDNativeStringPtr; 554 | p_contents: ptr char32_t; p_size: GDNativeInt) {.cdecl.} 555 | string_new_with_wide_chars_and_len*: proc (r_dest: GDNativeStringPtr; 556 | p_contents: ptr uint32; p_size: GDNativeInt) {.cdecl.} ## Information about the following functions: 557 | ## - The return value is the resulting encoded string length. 558 | ## - The length returned is in characters, not in bytes. It also does not include a trailing zero. 559 | ## - These functions also do not write trailing zero, If you need it, write it yourself at the position indicated by the length (and make sure to allocate it). 560 | ## - Passing NULL in r_text means only the length is computed (again, without including trailing zero). 561 | ## - p_max_write_length argument is in characters, not bytes. It will be ignored if r_text is NULL. 562 | ## - p_max_write_length argument does not affect the return value, it's only to cap write length. 563 | ## 564 | string_to_latin1_chars*: proc (p_self: GDNativeStringPtr; r_text: cstring; 565 | p_max_write_length: GDNativeInt): GDNativeInt {. 566 | cdecl.} 567 | string_to_utf8_chars*: proc (p_self: GDNativeStringPtr; r_text: cstring; 568 | p_max_write_length: GDNativeInt): GDNativeInt {. 569 | cdecl.} 570 | string_to_utf16_chars*: proc (p_self: GDNativeStringPtr; r_text: ptr char16_t; 571 | p_max_write_length: GDNativeInt): GDNativeInt {. 572 | cdecl.} 573 | string_to_utf32_chars*: proc (p_self: GDNativeStringPtr; r_text: ptr char32_t; 574 | p_max_write_length: GDNativeInt): GDNativeInt {. 575 | cdecl.} 576 | string_to_wide_chars*: proc (p_self: GDNativeStringPtr; r_text: ptr uint32; 577 | p_max_write_length: GDNativeInt): GDNativeInt {. 578 | cdecl.} 579 | string_operator_index*: proc (p_self: GDNativeStringPtr; p_index: GDNativeInt): ptr char32_t {. 580 | cdecl.} 581 | string_operator_index_const*: proc (p_self: GDNativeStringPtr; 582 | p_index: GDNativeInt): ptr char32_t {.cdecl.} ## Packed array functions 583 | packed_byte_array_operator_index*: proc (p_self: GDNativeTypePtr; 584 | p_index: GDNativeInt): ptr uint8 {.cdecl.} ## p_self should be a PackedByteArray 585 | packed_byte_array_operator_index_const*: proc (p_self: GDNativeTypePtr; 586 | p_index: GDNativeInt): ptr uint8 {.cdecl.} ## p_self should be a PackedByteArray 587 | packed_color_array_operator_index*: proc (p_self: GDNativeTypePtr; 588 | p_index: GDNativeInt): GDNativeTypePtr {.cdecl.} ## p_self should be a PackedColorArray, returns Color ptr 589 | packed_color_array_operator_index_const*: proc (p_self: GDNativeTypePtr; 590 | p_index: GDNativeInt): GDNativeTypePtr {.cdecl.} ## p_self should be a PackedColorArray, returns Color ptr 591 | packed_float32_array_operator_index*: proc (p_self: GDNativeTypePtr; 592 | p_index: GDNativeInt): ptr cfloat {.cdecl.} ## p_self should be a PackedFloat32Array 593 | packed_float32_array_operator_index_const*: proc (p_self: GDNativeTypePtr; 594 | p_index: GDNativeInt): ptr cfloat {.cdecl.} ## p_self should be a PackedFloat32Array 595 | packed_float64_array_operator_index*: proc (p_self: GDNativeTypePtr; 596 | p_index: GDNativeInt): ptr cdouble {.cdecl.} ## p_self should be a PackedFloat64Array 597 | packed_float64_array_operator_index_const*: proc (p_self: GDNativeTypePtr; 598 | p_index: GDNativeInt): ptr cdouble {.cdecl.} ## p_self should be a PackedFloat64Array 599 | packed_int32_array_operator_index*: proc (p_self: GDNativeTypePtr; 600 | p_index: GDNativeInt): ptr int32 {.cdecl.} ## p_self should be a PackedInt32Array 601 | packed_int32_array_operator_index_const*: proc (p_self: GDNativeTypePtr; 602 | p_index: GDNativeInt): ptr int32 {.cdecl.} ## p_self should be a PackedInt32Array 603 | packed_int64_array_operator_index*: proc (p_self: GDNativeTypePtr; 604 | p_index: GDNativeInt): ptr int64 {.cdecl.} ## p_self should be a PackedInt32Array 605 | packed_int64_array_operator_index_const*: proc (p_self: GDNativeTypePtr; 606 | p_index: GDNativeInt): ptr int64 {.cdecl.} ## p_self should be a PackedInt32Array 607 | packed_string_array_operator_index*: proc (p_self: GDNativeTypePtr; 608 | p_index: GDNativeInt): GDNativeStringPtr {.cdecl.} ## p_self should be a PackedStringArray 609 | packed_string_array_operator_index_const*: proc (p_self: GDNativeTypePtr; 610 | p_index: GDNativeInt): GDNativeStringPtr {.cdecl.} ## p_self should be a PackedStringArray 611 | packed_vector2_array_operator_index*: proc (p_self: GDNativeTypePtr; 612 | p_index: GDNativeInt): GDNativeTypePtr {.cdecl.} ## p_self should be a PackedVector2Array, returns Vector2 ptr 613 | packed_vector2_array_operator_index_const*: proc (p_self: GDNativeTypePtr; 614 | p_index: GDNativeInt): GDNativeTypePtr {.cdecl.} ## p_self should be a PackedVector2Array, returns Vector2 ptr 615 | packed_vector3_array_operator_index*: proc (p_self: GDNativeTypePtr; 616 | p_index: GDNativeInt): GDNativeTypePtr {.cdecl.} ## p_self should be a PackedVector3Array, returns Vector3 ptr 617 | packed_vector3_array_operator_index_const*: proc (p_self: GDNativeTypePtr; 618 | p_index: GDNativeInt): GDNativeTypePtr {.cdecl.} ## p_self should be a PackedVector3Array, returns Vector3 ptr 619 | array_operator_index*: proc (p_self: GDNativeTypePtr; p_index: GDNativeInt): GDNativeVariantPtr {. 620 | cdecl.} ## p_self should be an Array ptr 621 | array_operator_index_const*: proc (p_self: GDNativeTypePtr; p_index: GDNativeInt): GDNativeVariantPtr {. 622 | cdecl.} ## p_self should be an Array ptr 623 | ## Dictionary functions 624 | dictionary_operator_index*: proc (p_self: GDNativeTypePtr; 625 | p_key: GDNativeVariantPtr): GDNativeVariantPtr {. 626 | cdecl.} ## p_self should be an Dictionary ptr 627 | dictionary_operator_index_const*: proc (p_self: GDNativeTypePtr; 628 | p_key: GDNativeVariantPtr): GDNativeVariantPtr {.cdecl.} ## p_self should be an Dictionary ptr 629 | ## OBJECT 630 | object_method_bind_call*: proc (p_method_bind: GDNativeMethodBindPtr; 631 | p_instance: GDNativeObjectPtr; 632 | p_args: ptr GDNativeVariantPtr; 633 | p_arg_count: GDNativeInt; 634 | r_ret: GDNativeVariantPtr; 635 | r_error: ptr GDNativeCallError) {.cdecl.} 636 | object_method_bind_ptrcall*: proc (p_method_bind: GDNativeMethodBindPtr; 637 | p_instance: GDNativeObjectPtr; 638 | p_args: ptr GDNativeTypePtr; 639 | r_ret: GDNativeTypePtr) {.cdecl.} 640 | object_destroy*: proc (p_o: GDNativeObjectPtr) {.cdecl.} 641 | global_get_singleton*: proc (p_name: cstring): GDNativeObjectPtr {.cdecl.} 642 | object_get_instance_binding*: proc (p_o: GDNativeObjectPtr; p_token: pointer; 643 | p_callbacks: ptr GDNativeInstanceBindingCallbacks): pointer {.cdecl.} 644 | object_set_instance_binding*: proc (p_o: GDNativeObjectPtr; p_token: pointer; 645 | p_binding: pointer; p_callbacks: ptr GDNativeInstanceBindingCallbacks) {. 646 | cdecl.} 647 | object_set_instance*: proc (p_o: GDNativeObjectPtr; p_classname: cstring; 648 | p_instance: GDExtensionClassInstancePtr) {.cdecl.} ## p_classname should be a registered extension class and should extend the p_o object's class. 649 | object_cast_to*: proc (p_object: GDNativeObjectPtr; p_class_tag: pointer): GDNativeObjectPtr {. 650 | cdecl.} 651 | object_get_instance_from_id*: proc (p_instance_id: GDObjectInstanceID): GDNativeObjectPtr {. 652 | cdecl.} 653 | object_get_instance_id*: proc (p_object: GDNativeObjectPtr): GDObjectInstanceID {. 654 | cdecl.} ## SCRIPT INSTANCE 655 | script_instance_create*: proc (p_info: ptr GDNativeExtensionScriptInstanceInfo; 656 | p_instance_data: GDNativeExtensionScriptInstanceDataPtr): GDNativeScriptInstancePtr {. 657 | cdecl.} ## CLASSDB 658 | classdb_construct_object*: proc (p_classname: cstring): GDNativeObjectPtr {.cdecl.} ## The passed class must be a built-in godot class, or an already-registered extension class. In both case, object_set_instance should be called to fully initialize the object. 659 | classdb_get_method_bind*: proc (p_classname: cstring; p_methodname: cstring; 660 | p_hash: GDNativeInt): GDNativeMethodBindPtr {. 661 | cdecl.} 662 | classdb_get_class_tag*: proc (p_classname: cstring): pointer {.cdecl.} ## CLASSDB EXTENSION 663 | classdb_register_extension_class*: proc ( 664 | p_library: GDNativeExtensionClassLibraryPtr; p_class_name: cstring; 665 | p_parent_class_name: cstring; 666 | p_extension_funcs: ptr GDNativeExtensionClassCreationInfo) {.cdecl.} 667 | classdb_register_extension_class_method*: proc ( 668 | p_library: GDNativeExtensionClassLibraryPtr; p_class_name: cstring; 669 | p_method_info: ptr GDNativeExtensionClassMethodInfo) {.cdecl.} 670 | classdb_register_extension_class_integer_constant*: proc ( 671 | p_library: GDNativeExtensionClassLibraryPtr; p_class_name: cstring; 672 | p_enum_name: cstring; p_constant_name: cstring; 673 | p_constant_value: GDNativeInt; p_is_bitfield: GDNativeBool) {.cdecl.} 674 | classdb_register_extension_class_property*: proc ( 675 | p_library: GDNativeExtensionClassLibraryPtr; p_class_name: cstring; 676 | p_info: ptr GDNativePropertyInfo; p_setter: cstring; p_getter: cstring) {.cdecl.} 677 | classdb_register_extension_class_property_group*: proc ( 678 | p_library: GDNativeExtensionClassLibraryPtr; p_class_name: cstring; 679 | p_group_name: cstring; p_prefix: cstring) {.cdecl.} 680 | classdb_register_extension_class_property_subgroup*: proc ( 681 | p_library: GDNativeExtensionClassLibraryPtr; p_class_name: cstring; 682 | p_subgroup_name: cstring; p_prefix: cstring) {.cdecl.} 683 | classdb_register_extension_class_signal*: proc ( 684 | p_library: GDNativeExtensionClassLibraryPtr; p_class_name: cstring; 685 | p_signal_name: cstring; p_argument_info: ptr GDNativePropertyInfo; 686 | p_argument_count: GDNativeInt) {.cdecl.} 687 | classdb_unregister_extension_class*: proc ( 688 | p_library: GDNativeExtensionClassLibraryPtr; p_class_name: cstring) {.cdecl.} ## Unregistering a parent class before a class that inherits it will result in failure. Inheritors must be unregistered first. 689 | get_library_path*: proc (p_library: GDNativeExtensionClassLibraryPtr; 690 | r_path: GDNativeStringPtr) {.cdecl.} 691 | 692 | 693 | ## INITIALIZATION 694 | 695 | type 696 | GDNativeInitializationLevel* = enum 697 | GDNATIVE_INITIALIZATION_CORE, GDNATIVE_INITIALIZATION_SERVERS, 698 | GDNATIVE_INITIALIZATION_SCENE, GDNATIVE_INITIALIZATION_EDITOR, 699 | GDNATIVE_MAX_INITIALIZATION_LEVEL 700 | GDNativeInitialization* {.bycopy.} = object 701 | minimum_initialization_level*: GDNativeInitializationLevel ## Minimum initialization level required. 702 | ## If Core or Servers, the extension needs editor or game restart to take effect 703 | ## Up to the user to supply when initializing 704 | userdata*: pointer ## This function will be called multiple times for each initialization level. 705 | initialize*: proc (userdata: pointer; p_level: GDNativeInitializationLevel) {. 706 | cdecl.} 707 | deinitialize*: proc (userdata: pointer; p_level: GDNativeInitializationLevel) {. 708 | cdecl.} 709 | 710 | 711 | 712 | ## Define a C function prototype that implements the function below and expose it to dlopen() (or similar). 713 | ## It will be called on initialization. The name must be an unique one specified in the .gdextension config file. 714 | ## 715 | 716 | type 717 | GDNativeInitializationFunction* = proc (p_interface: ptr GDNativeInterface; 718 | p_library: GDNativeExtensionClassLibraryPtr; r_initialization: ptr GDNativeInitialization): GDNativeBool {. 719 | cdecl.} 720 | --------------------------------------------------------------------------------