mirror of
https://github.com/godotengine/godot-headers.git
synced 2026-01-03 18:09:13 +03:00
updated headers and added pluginscript and nativearvr
This commit is contained in:
Karroffel
@@ -46,11 +46,20 @@ typedef struct {
|
||||
} godot_array;
|
||||
#endif
|
||||
|
||||
// reduce extern "C" nesting for VS2013
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <gdnative/pool_arrays.h>
|
||||
#include <gdnative/variant.h>
|
||||
|
||||
#include <gdnative/gdnative.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void GDAPI godot_array_new(godot_array *r_dest);
|
||||
void GDAPI godot_array_new_copy(godot_array *r_dest, const godot_array *p_src);
|
||||
void GDAPI godot_array_new_pool_color_array(godot_array *r_dest, const godot_pool_color_array *p_pca);
|
||||
|
||||
@@ -45,10 +45,19 @@ typedef struct {
|
||||
} godot_basis;
|
||||
#endif
|
||||
|
||||
// reduce extern "C" nesting for VS2013
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <gdnative/gdnative.h>
|
||||
#include <gdnative/quat.h>
|
||||
#include <gdnative/vector3.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void GDAPI godot_basis_new_with_rows(godot_basis *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis);
|
||||
void GDAPI godot_basis_new_with_axis_and_angle(godot_basis *r_dest, const godot_vector3 *p_axis, const godot_real p_phi);
|
||||
void GDAPI godot_basis_new_with_euler(godot_basis *r_dest, const godot_vector3 *p_euler);
|
||||
|
||||
@@ -45,9 +45,18 @@ typedef struct {
|
||||
} godot_color;
|
||||
#endif
|
||||
|
||||
// reduce extern "C" nesting for VS2013
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <gdnative/gdnative.h>
|
||||
#include <gdnative/string.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void GDAPI godot_color_new_rgba(godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b, const godot_real p_a);
|
||||
void GDAPI godot_color_new_rgb(godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b);
|
||||
|
||||
|
||||
@@ -45,10 +45,19 @@ typedef struct {
|
||||
} godot_dictionary;
|
||||
#endif
|
||||
|
||||
// reduce extern "C" nesting for VS2013
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <gdnative/array.h>
|
||||
#include <gdnative/gdnative.h>
|
||||
#include <gdnative/variant.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void GDAPI godot_dictionary_new(godot_dictionary *r_dest);
|
||||
void GDAPI godot_dictionary_new_copy(godot_dictionary *r_dest, const godot_dictionary *p_src);
|
||||
void GDAPI godot_dictionary_destroy(godot_dictionary *p_self);
|
||||
|
||||
@@ -34,18 +34,9 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifdef GDAPI_BUILT_IN
|
||||
#define GDAPI_EXPORT
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
#if defined(GDAPI_EXPORT)
|
||||
#define GDCALLINGCONV
|
||||
#define GDAPI __declspec(dllexport) GDCALLINGCONV
|
||||
#else
|
||||
#define GDCALLINGCONV
|
||||
#define GDAPI __declspec(dllimport) GDCALLINGCONV
|
||||
#endif
|
||||
#define GDAPI GDCALLINGCONV
|
||||
#elif defined(__APPLE__)
|
||||
#include "TargetConditionals.h"
|
||||
#if TARGET_OS_IPHONE
|
||||
@@ -56,7 +47,7 @@ extern "C" {
|
||||
#define GDAPI GDCALLINGCONV
|
||||
#endif
|
||||
#else
|
||||
#define GDCALLINGCONV __attribute__((sysv_abi, visibility("default")))
|
||||
#define GDCALLINGCONV __attribute__((sysv_abi))
|
||||
#define GDAPI GDCALLINGCONV
|
||||
#endif
|
||||
|
||||
@@ -150,6 +141,10 @@ typedef void godot_object;
|
||||
|
||||
#include <gdnative/string.h>
|
||||
|
||||
/////// String name
|
||||
|
||||
#include <gdnative/string_name.h>
|
||||
|
||||
////// Vector2
|
||||
|
||||
#include <gdnative/vector2.h>
|
||||
@@ -243,6 +238,7 @@ typedef struct {
|
||||
uint64_t no_api_hash;
|
||||
godot_object *gd_native_library; // pointer to GDNativeLibrary that is being initialized
|
||||
const struct godot_gdnative_api_struct *api_struct;
|
||||
const godot_string *active_library_path;
|
||||
} godot_gdnative_init_options;
|
||||
|
||||
typedef struct {
|
||||
@@ -259,7 +255,7 @@ godot_dictionary GDAPI godot_get_global_constants();
|
||||
////// GDNative procedure types
|
||||
typedef void (*godot_gdnative_init_fn)(godot_gdnative_init_options *);
|
||||
typedef void (*godot_gdnative_terminate_fn)(godot_gdnative_terminate_options *);
|
||||
typedef godot_variant (*godot_gdnative_procedure_fn)(void *, godot_array *);
|
||||
typedef godot_variant (*godot_gdnative_procedure_fn)(godot_array *);
|
||||
|
||||
////// System Functions
|
||||
|
||||
|
||||
@@ -45,9 +45,18 @@ typedef struct {
|
||||
} godot_node_path;
|
||||
#endif
|
||||
|
||||
// reduce extern "C" nesting for VS2013
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <gdnative/gdnative.h>
|
||||
#include <gdnative/string.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void GDAPI godot_node_path_new(godot_node_path *r_dest, const godot_string *p_from);
|
||||
void GDAPI godot_node_path_new_copy(godot_node_path *r_dest, const godot_node_path *p_src);
|
||||
void GDAPI godot_node_path_destroy(godot_node_path *p_self);
|
||||
|
||||
@@ -45,9 +45,18 @@ typedef struct {
|
||||
} godot_plane;
|
||||
#endif
|
||||
|
||||
// reduce extern "C" nesting for VS2013
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <gdnative/gdnative.h>
|
||||
#include <gdnative/vector3.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void GDAPI godot_plane_new_with_reals(godot_plane *r_dest, const godot_real p_a, const godot_real p_b, const godot_real p_c, const godot_real p_d);
|
||||
void GDAPI godot_plane_new_with_vectors(godot_plane *r_dest, const godot_vector3 *p_v1, const godot_vector3 *p_v2, const godot_vector3 *p_v3);
|
||||
void GDAPI godot_plane_new_with_normal(godot_plane *r_dest, const godot_vector3 *p_normal, const godot_real p_d);
|
||||
|
||||
@@ -113,6 +113,11 @@ typedef struct {
|
||||
} godot_pool_color_array;
|
||||
#endif
|
||||
|
||||
// reduce extern "C" nesting for VS2013
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <gdnative/array.h>
|
||||
#include <gdnative/color.h>
|
||||
#include <gdnative/vector2.h>
|
||||
@@ -120,6 +125,10 @@ typedef struct {
|
||||
|
||||
#include <gdnative/gdnative.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// byte
|
||||
|
||||
void GDAPI godot_pool_byte_array_new(godot_pool_byte_array *r_dest);
|
||||
|
||||
@@ -45,9 +45,18 @@ typedef struct {
|
||||
} godot_quat;
|
||||
#endif
|
||||
|
||||
// reduce extern "C" nesting for VS2013
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <gdnative/gdnative.h>
|
||||
#include <gdnative/vector3.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void GDAPI godot_quat_new(godot_quat *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z, const godot_real p_w);
|
||||
void GDAPI godot_quat_new_with_axis_angle(godot_quat *r_dest, const godot_vector3 *p_axis, const godot_real p_angle);
|
||||
|
||||
|
||||
@@ -43,9 +43,18 @@ typedef struct godot_rect2 {
|
||||
} godot_rect2;
|
||||
#endif
|
||||
|
||||
// reduce extern "C" nesting for VS2013
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <gdnative/gdnative.h>
|
||||
#include <gdnative/vector2.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void GDAPI godot_rect2_new_with_position_and_size(godot_rect2 *r_dest, const godot_vector2 *p_pos, const godot_vector2 *p_size);
|
||||
void GDAPI godot_rect2_new(godot_rect2 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_width, const godot_real p_height);
|
||||
|
||||
|
||||
@@ -45,10 +45,19 @@ typedef struct {
|
||||
} godot_rect3;
|
||||
#endif
|
||||
|
||||
// reduce extern "C" nesting for VS2013
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <gdnative/gdnative.h>
|
||||
#include <gdnative/plane.h>
|
||||
#include <gdnative/vector3.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void GDAPI godot_rect3_new(godot_rect3 *r_dest, const godot_vector3 *p_pos, const godot_vector3 *p_size);
|
||||
|
||||
godot_vector3 GDAPI godot_rect3_get_position(const godot_rect3 *p_self);
|
||||
|
||||
@@ -45,8 +45,17 @@ typedef struct {
|
||||
} godot_rid;
|
||||
#endif
|
||||
|
||||
// reduce extern "C" nesting for VS2013
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <gdnative/gdnative.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void GDAPI godot_rid_new(godot_rid *r_dest);
|
||||
|
||||
godot_int GDAPI godot_rid_get_id(const godot_rid *p_self);
|
||||
|
||||
@@ -46,9 +46,18 @@ typedef struct {
|
||||
} godot_string;
|
||||
#endif
|
||||
|
||||
// reduce extern "C" nesting for VS2013
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <gdnative/gdnative.h>
|
||||
#include <gdnative/variant.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void GDAPI godot_string_new(godot_string *r_dest);
|
||||
void GDAPI godot_string_new_copy(godot_string *r_dest, const godot_string *p_src);
|
||||
void GDAPI godot_string_new_data(godot_string *r_dest, const char *p_contents, const int p_size);
|
||||
|
||||
77
gdnative/string_name.h
Normal file
77
gdnative/string_name.h
Normal file
@@ -0,0 +1,77 @@
|
||||
/*************************************************************************/
|
||||
/* string_name.h */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* http://www.godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
#ifndef GODOT_STRING_NAME_H
|
||||
#define GODOT_STRING_NAME_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stdint.h>
|
||||
#include <wchar.h>
|
||||
|
||||
#define GODOT_STRING_NAME_SIZE sizeof(void *)
|
||||
|
||||
#ifndef GODOT_CORE_API_GODOT_STRING_NAME_TYPE_DEFINED
|
||||
#define GODOT_CORE_API_GODOT_STRING_NAME_TYPE_DEFINED
|
||||
typedef struct {
|
||||
uint8_t _dont_touch_that[GODOT_STRING_NAME_SIZE];
|
||||
} godot_string_name;
|
||||
#endif
|
||||
|
||||
// reduce extern "C" nesting for VS2013
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <gdnative/gdnative.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void GDAPI godot_string_name_new(godot_string_name *r_dest, const godot_string *p_name);
|
||||
void GDAPI godot_string_name_new_data(godot_string_name *r_dest, const char *p_name);
|
||||
|
||||
godot_string GDAPI godot_string_name_get_name(const godot_string_name *p_self);
|
||||
|
||||
uint32_t GDAPI godot_string_name_get_hash(const godot_string_name *p_self);
|
||||
const void GDAPI *godot_string_name_get_data_unique_pointer(const godot_string_name *p_self);
|
||||
|
||||
godot_bool GDAPI godot_string_name_operator_equal(const godot_string_name *p_self, const godot_string_name *p_other);
|
||||
godot_bool GDAPI godot_string_name_operator_less(const godot_string_name *p_self, const godot_string_name *p_other);
|
||||
|
||||
void GDAPI godot_string_name_destroy(godot_string_name *p_self);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // GODOT_STRING_NAME_H
|
||||
@@ -45,11 +45,20 @@ typedef struct {
|
||||
} godot_transform;
|
||||
#endif
|
||||
|
||||
// reduce extern "C" nesting for VS2013
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <gdnative/basis.h>
|
||||
#include <gdnative/gdnative.h>
|
||||
#include <gdnative/variant.h>
|
||||
#include <gdnative/vector3.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void GDAPI godot_transform_new_with_axis_origin(godot_transform *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis, const godot_vector3 *p_origin);
|
||||
void GDAPI godot_transform_new(godot_transform *r_dest, const godot_basis *p_basis, const godot_vector3 *p_origin);
|
||||
|
||||
|
||||
@@ -45,10 +45,19 @@ typedef struct {
|
||||
} godot_transform2d;
|
||||
#endif
|
||||
|
||||
// reduce extern "C" nesting for VS2013
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <gdnative/gdnative.h>
|
||||
#include <gdnative/variant.h>
|
||||
#include <gdnative/vector2.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void GDAPI godot_transform2d_new(godot_transform2d *r_dest, const godot_real p_rot, const godot_vector2 *p_pos);
|
||||
void GDAPI godot_transform2d_new_axis_origin(godot_transform2d *r_dest, const godot_vector2 *p_x_axis, const godot_vector2 *p_y_axis, const godot_vector2 *p_origin);
|
||||
|
||||
|
||||
@@ -99,6 +99,11 @@ typedef struct godot_variant_call_error {
|
||||
godot_variant_type expected;
|
||||
} godot_variant_call_error;
|
||||
|
||||
// reduce extern "C" nesting for VS2013
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <gdnative/array.h>
|
||||
#include <gdnative/basis.h>
|
||||
#include <gdnative/color.h>
|
||||
@@ -119,6 +124,10 @@ typedef struct godot_variant_call_error {
|
||||
|
||||
#include <gdnative/gdnative.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
godot_variant_type GDAPI godot_variant_get_type(const godot_variant *p_v);
|
||||
|
||||
void GDAPI godot_variant_new_copy(godot_variant *r_dest, const godot_variant *p_src);
|
||||
|
||||
@@ -45,8 +45,17 @@ typedef struct {
|
||||
} godot_vector2;
|
||||
#endif
|
||||
|
||||
// reduce extern "C" nesting for VS2013
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <gdnative/gdnative.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void GDAPI godot_vector2_new(godot_vector2 *r_dest, const godot_real p_x, const godot_real p_y);
|
||||
|
||||
godot_string GDAPI godot_vector2_as_string(const godot_vector2 *p_self);
|
||||
|
||||
@@ -45,9 +45,18 @@ typedef struct {
|
||||
} godot_vector3;
|
||||
#endif
|
||||
|
||||
// reduce extern "C" nesting for VS2013
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include <gdnative/basis.h>
|
||||
#include <gdnative/gdnative.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef enum {
|
||||
GODOT_VECTOR3_AXIS_X,
|
||||
GODOT_VECTOR3_AXIS_Y,
|
||||
|
||||
5313
gdnative_api.json
Normal file
5313
gdnative_api.json
Normal file
File diff suppressed because it is too large
Load Diff
705
gdnative_api_struct.gen.h
Normal file
705
gdnative_api_struct.gen.h
Normal file
@@ -0,0 +1,705 @@
|
||||
/* THIS FILE IS GENERATED DO NOT EDIT */
|
||||
#ifndef GODOT_GDNATIVE_API_STRUCT_H
|
||||
#define GODOT_GDNATIVE_API_STRUCT_H
|
||||
|
||||
#include <gdnative/gdnative.h>
|
||||
#include <nativearvr/godot_nativearvr.h>
|
||||
#include <nativescript/godot_nativescript.h>
|
||||
#include <pluginscript/godot_pluginscript.h>
|
||||
|
||||
#define GDNATIVE_API_INIT(options) do { extern const godot_gdnative_api_struct *_gdnative_wrapper_api_struct; _gdnative_wrapper_api_struct = options->api_struct; } while (0)
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct godot_gdnative_api_struct {
|
||||
void *next;
|
||||
const char *version;
|
||||
void (*godot_color_new_rgba)(godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b, const godot_real p_a);
|
||||
void (*godot_color_new_rgb)(godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b);
|
||||
godot_real (*godot_color_get_r)(const godot_color *p_self);
|
||||
void (*godot_color_set_r)(godot_color *p_self, const godot_real r);
|
||||
godot_real (*godot_color_get_g)(const godot_color *p_self);
|
||||
void (*godot_color_set_g)(godot_color *p_self, const godot_real g);
|
||||
godot_real (*godot_color_get_b)(const godot_color *p_self);
|
||||
void (*godot_color_set_b)(godot_color *p_self, const godot_real b);
|
||||
godot_real (*godot_color_get_a)(const godot_color *p_self);
|
||||
void (*godot_color_set_a)(godot_color *p_self, const godot_real a);
|
||||
godot_real (*godot_color_get_h)(const godot_color *p_self);
|
||||
godot_real (*godot_color_get_s)(const godot_color *p_self);
|
||||
godot_real (*godot_color_get_v)(const godot_color *p_self);
|
||||
godot_string (*godot_color_as_string)(const godot_color *p_self);
|
||||
godot_int (*godot_color_to_rgba32)(const godot_color *p_self);
|
||||
godot_int (*godot_color_to_argb32)(const godot_color *p_self);
|
||||
godot_real (*godot_color_gray)(const godot_color *p_self);
|
||||
godot_color (*godot_color_inverted)(const godot_color *p_self);
|
||||
godot_color (*godot_color_contrasted)(const godot_color *p_self);
|
||||
godot_color (*godot_color_linear_interpolate)(const godot_color *p_self, const godot_color *p_b, const godot_real p_t);
|
||||
godot_color (*godot_color_blend)(const godot_color *p_self, const godot_color *p_over);
|
||||
godot_string (*godot_color_to_html)(const godot_color *p_self, const godot_bool p_with_alpha);
|
||||
godot_bool (*godot_color_operator_equal)(const godot_color *p_self, const godot_color *p_b);
|
||||
godot_bool (*godot_color_operator_less)(const godot_color *p_self, const godot_color *p_b);
|
||||
void (*godot_vector2_new)(godot_vector2 *r_dest, const godot_real p_x, const godot_real p_y);
|
||||
godot_string (*godot_vector2_as_string)(const godot_vector2 *p_self);
|
||||
godot_vector2 (*godot_vector2_normalized)(const godot_vector2 *p_self);
|
||||
godot_real (*godot_vector2_length)(const godot_vector2 *p_self);
|
||||
godot_real (*godot_vector2_angle)(const godot_vector2 *p_self);
|
||||
godot_real (*godot_vector2_length_squared)(const godot_vector2 *p_self);
|
||||
godot_bool (*godot_vector2_is_normalized)(const godot_vector2 *p_self);
|
||||
godot_real (*godot_vector2_distance_to)(const godot_vector2 *p_self, const godot_vector2 *p_to);
|
||||
godot_real (*godot_vector2_distance_squared_to)(const godot_vector2 *p_self, const godot_vector2 *p_to);
|
||||
godot_real (*godot_vector2_angle_to)(const godot_vector2 *p_self, const godot_vector2 *p_to);
|
||||
godot_real (*godot_vector2_angle_to_point)(const godot_vector2 *p_self, const godot_vector2 *p_to);
|
||||
godot_vector2 (*godot_vector2_linear_interpolate)(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_real p_t);
|
||||
godot_vector2 (*godot_vector2_cubic_interpolate)(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_vector2 *p_pre_a, const godot_vector2 *p_post_b, const godot_real p_t);
|
||||
godot_vector2 (*godot_vector2_rotated)(const godot_vector2 *p_self, const godot_real p_phi);
|
||||
godot_vector2 (*godot_vector2_tangent)(const godot_vector2 *p_self);
|
||||
godot_vector2 (*godot_vector2_floor)(const godot_vector2 *p_self);
|
||||
godot_vector2 (*godot_vector2_snapped)(const godot_vector2 *p_self, const godot_vector2 *p_by);
|
||||
godot_real (*godot_vector2_aspect)(const godot_vector2 *p_self);
|
||||
godot_real (*godot_vector2_dot)(const godot_vector2 *p_self, const godot_vector2 *p_with);
|
||||
godot_vector2 (*godot_vector2_slide)(const godot_vector2 *p_self, const godot_vector2 *p_n);
|
||||
godot_vector2 (*godot_vector2_bounce)(const godot_vector2 *p_self, const godot_vector2 *p_n);
|
||||
godot_vector2 (*godot_vector2_reflect)(const godot_vector2 *p_self, const godot_vector2 *p_n);
|
||||
godot_vector2 (*godot_vector2_abs)(const godot_vector2 *p_self);
|
||||
godot_vector2 (*godot_vector2_clamped)(const godot_vector2 *p_self, const godot_real p_length);
|
||||
godot_vector2 (*godot_vector2_operator_add)(const godot_vector2 *p_self, const godot_vector2 *p_b);
|
||||
godot_vector2 (*godot_vector2_operator_substract)(const godot_vector2 *p_self, const godot_vector2 *p_b);
|
||||
godot_vector2 (*godot_vector2_operator_multiply_vector)(const godot_vector2 *p_self, const godot_vector2 *p_b);
|
||||
godot_vector2 (*godot_vector2_operator_multiply_scalar)(const godot_vector2 *p_self, const godot_real p_b);
|
||||
godot_vector2 (*godot_vector2_operator_divide_vector)(const godot_vector2 *p_self, const godot_vector2 *p_b);
|
||||
godot_vector2 (*godot_vector2_operator_divide_scalar)(const godot_vector2 *p_self, const godot_real p_b);
|
||||
godot_bool (*godot_vector2_operator_equal)(const godot_vector2 *p_self, const godot_vector2 *p_b);
|
||||
godot_bool (*godot_vector2_operator_less)(const godot_vector2 *p_self, const godot_vector2 *p_b);
|
||||
godot_vector2 (*godot_vector2_operator_neg)(const godot_vector2 *p_self);
|
||||
void (*godot_vector2_set_x)(godot_vector2 *p_self, const godot_real p_x);
|
||||
void (*godot_vector2_set_y)(godot_vector2 *p_self, const godot_real p_y);
|
||||
godot_real (*godot_vector2_get_x)(const godot_vector2 *p_self);
|
||||
godot_real (*godot_vector2_get_y)(const godot_vector2 *p_self);
|
||||
void (*godot_quat_new)(godot_quat *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z, const godot_real p_w);
|
||||
void (*godot_quat_new_with_axis_angle)(godot_quat *r_dest, const godot_vector3 *p_axis, const godot_real p_angle);
|
||||
godot_real (*godot_quat_get_x)(const godot_quat *p_self);
|
||||
void (*godot_quat_set_x)(godot_quat *p_self, const godot_real val);
|
||||
godot_real (*godot_quat_get_y)(const godot_quat *p_self);
|
||||
void (*godot_quat_set_y)(godot_quat *p_self, const godot_real val);
|
||||
godot_real (*godot_quat_get_z)(const godot_quat *p_self);
|
||||
void (*godot_quat_set_z)(godot_quat *p_self, const godot_real val);
|
||||
godot_real (*godot_quat_get_w)(const godot_quat *p_self);
|
||||
void (*godot_quat_set_w)(godot_quat *p_self, const godot_real val);
|
||||
godot_string (*godot_quat_as_string)(const godot_quat *p_self);
|
||||
godot_real (*godot_quat_length)(const godot_quat *p_self);
|
||||
godot_real (*godot_quat_length_squared)(const godot_quat *p_self);
|
||||
godot_quat (*godot_quat_normalized)(const godot_quat *p_self);
|
||||
godot_bool (*godot_quat_is_normalized)(const godot_quat *p_self);
|
||||
godot_quat (*godot_quat_inverse)(const godot_quat *p_self);
|
||||
godot_real (*godot_quat_dot)(const godot_quat *p_self, const godot_quat *p_b);
|
||||
godot_vector3 (*godot_quat_xform)(const godot_quat *p_self, const godot_vector3 *p_v);
|
||||
godot_quat (*godot_quat_slerp)(const godot_quat *p_self, const godot_quat *p_b, const godot_real p_t);
|
||||
godot_quat (*godot_quat_slerpni)(const godot_quat *p_self, const godot_quat *p_b, const godot_real p_t);
|
||||
godot_quat (*godot_quat_cubic_slerp)(const godot_quat *p_self, const godot_quat *p_b, const godot_quat *p_pre_a, const godot_quat *p_post_b, const godot_real p_t);
|
||||
godot_quat (*godot_quat_operator_multiply)(const godot_quat *p_self, const godot_real p_b);
|
||||
godot_quat (*godot_quat_operator_add)(const godot_quat *p_self, const godot_quat *p_b);
|
||||
godot_quat (*godot_quat_operator_substract)(const godot_quat *p_self, const godot_quat *p_b);
|
||||
godot_quat (*godot_quat_operator_divide)(const godot_quat *p_self, const godot_real p_b);
|
||||
godot_bool (*godot_quat_operator_equal)(const godot_quat *p_self, const godot_quat *p_b);
|
||||
godot_quat (*godot_quat_operator_neg)(const godot_quat *p_self);
|
||||
void (*godot_basis_new_with_rows)(godot_basis *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis);
|
||||
void (*godot_basis_new_with_axis_and_angle)(godot_basis *r_dest, const godot_vector3 *p_axis, const godot_real p_phi);
|
||||
void (*godot_basis_new_with_euler)(godot_basis *r_dest, const godot_vector3 *p_euler);
|
||||
godot_string (*godot_basis_as_string)(const godot_basis *p_self);
|
||||
godot_basis (*godot_basis_inverse)(const godot_basis *p_self);
|
||||
godot_basis (*godot_basis_transposed)(const godot_basis *p_self);
|
||||
godot_basis (*godot_basis_orthonormalized)(const godot_basis *p_self);
|
||||
godot_real (*godot_basis_determinant)(const godot_basis *p_self);
|
||||
godot_basis (*godot_basis_rotated)(const godot_basis *p_self, const godot_vector3 *p_axis, const godot_real p_phi);
|
||||
godot_basis (*godot_basis_scaled)(const godot_basis *p_self, const godot_vector3 *p_scale);
|
||||
godot_vector3 (*godot_basis_get_scale)(const godot_basis *p_self);
|
||||
godot_vector3 (*godot_basis_get_euler)(const godot_basis *p_self);
|
||||
godot_real (*godot_basis_tdotx)(const godot_basis *p_self, const godot_vector3 *p_with);
|
||||
godot_real (*godot_basis_tdoty)(const godot_basis *p_self, const godot_vector3 *p_with);
|
||||
godot_real (*godot_basis_tdotz)(const godot_basis *p_self, const godot_vector3 *p_with);
|
||||
godot_vector3 (*godot_basis_xform)(const godot_basis *p_self, const godot_vector3 *p_v);
|
||||
godot_vector3 (*godot_basis_xform_inv)(const godot_basis *p_self, const godot_vector3 *p_v);
|
||||
godot_int (*godot_basis_get_orthogonal_index)(const godot_basis *p_self);
|
||||
void (*godot_basis_new)(godot_basis *r_dest);
|
||||
void (*godot_basis_new_with_euler_quat)(godot_basis *r_dest, const godot_quat *p_euler);
|
||||
void (*godot_basis_get_elements)(godot_basis *p_self, godot_vector3 *p_elements);
|
||||
godot_vector3 (*godot_basis_get_axis)(const godot_basis *p_self, const godot_int p_axis);
|
||||
void (*godot_basis_set_axis)(godot_basis *p_self, const godot_int p_axis, const godot_vector3 *p_value);
|
||||
godot_vector3 (*godot_basis_get_row)(const godot_basis *p_self, const godot_int p_row);
|
||||
void (*godot_basis_set_row)(godot_basis *p_self, const godot_int p_row, const godot_vector3 *p_value);
|
||||
godot_bool (*godot_basis_operator_equal)(const godot_basis *p_self, const godot_basis *p_b);
|
||||
godot_basis (*godot_basis_operator_add)(const godot_basis *p_self, const godot_basis *p_b);
|
||||
godot_basis (*godot_basis_operator_substract)(const godot_basis *p_self, const godot_basis *p_b);
|
||||
godot_basis (*godot_basis_operator_multiply_vector)(const godot_basis *p_self, const godot_basis *p_b);
|
||||
godot_basis (*godot_basis_operator_multiply_scalar)(const godot_basis *p_self, const godot_real p_b);
|
||||
void (*godot_vector3_new)(godot_vector3 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z);
|
||||
godot_string (*godot_vector3_as_string)(const godot_vector3 *p_self);
|
||||
godot_int (*godot_vector3_min_axis)(const godot_vector3 *p_self);
|
||||
godot_int (*godot_vector3_max_axis)(const godot_vector3 *p_self);
|
||||
godot_real (*godot_vector3_length)(const godot_vector3 *p_self);
|
||||
godot_real (*godot_vector3_length_squared)(const godot_vector3 *p_self);
|
||||
godot_bool (*godot_vector3_is_normalized)(const godot_vector3 *p_self);
|
||||
godot_vector3 (*godot_vector3_normalized)(const godot_vector3 *p_self);
|
||||
godot_vector3 (*godot_vector3_inverse)(const godot_vector3 *p_self);
|
||||
godot_vector3 (*godot_vector3_snapped)(const godot_vector3 *p_self, const godot_vector3 *p_by);
|
||||
godot_vector3 (*godot_vector3_rotated)(const godot_vector3 *p_self, const godot_vector3 *p_axis, const godot_real p_phi);
|
||||
godot_vector3 (*godot_vector3_linear_interpolate)(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_real p_t);
|
||||
godot_vector3 (*godot_vector3_cubic_interpolate)(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_vector3 *p_pre_a, const godot_vector3 *p_post_b, const godot_real p_t);
|
||||
godot_real (*godot_vector3_dot)(const godot_vector3 *p_self, const godot_vector3 *p_b);
|
||||
godot_vector3 (*godot_vector3_cross)(const godot_vector3 *p_self, const godot_vector3 *p_b);
|
||||
godot_basis (*godot_vector3_outer)(const godot_vector3 *p_self, const godot_vector3 *p_b);
|
||||
godot_basis (*godot_vector3_to_diagonal_matrix)(const godot_vector3 *p_self);
|
||||
godot_vector3 (*godot_vector3_abs)(const godot_vector3 *p_self);
|
||||
godot_vector3 (*godot_vector3_floor)(const godot_vector3 *p_self);
|
||||
godot_vector3 (*godot_vector3_ceil)(const godot_vector3 *p_self);
|
||||
godot_real (*godot_vector3_distance_to)(const godot_vector3 *p_self, const godot_vector3 *p_b);
|
||||
godot_real (*godot_vector3_distance_squared_to)(const godot_vector3 *p_self, const godot_vector3 *p_b);
|
||||
godot_real (*godot_vector3_angle_to)(const godot_vector3 *p_self, const godot_vector3 *p_to);
|
||||
godot_vector3 (*godot_vector3_slide)(const godot_vector3 *p_self, const godot_vector3 *p_n);
|
||||
godot_vector3 (*godot_vector3_bounce)(const godot_vector3 *p_self, const godot_vector3 *p_n);
|
||||
godot_vector3 (*godot_vector3_reflect)(const godot_vector3 *p_self, const godot_vector3 *p_n);
|
||||
godot_vector3 (*godot_vector3_operator_add)(const godot_vector3 *p_self, const godot_vector3 *p_b);
|
||||
godot_vector3 (*godot_vector3_operator_substract)(const godot_vector3 *p_self, const godot_vector3 *p_b);
|
||||
godot_vector3 (*godot_vector3_operator_multiply_vector)(const godot_vector3 *p_self, const godot_vector3 *p_b);
|
||||
godot_vector3 (*godot_vector3_operator_multiply_scalar)(const godot_vector3 *p_self, const godot_real p_b);
|
||||
godot_vector3 (*godot_vector3_operator_divide_vector)(const godot_vector3 *p_self, const godot_vector3 *p_b);
|
||||
godot_vector3 (*godot_vector3_operator_divide_scalar)(const godot_vector3 *p_self, const godot_real p_b);
|
||||
godot_bool (*godot_vector3_operator_equal)(const godot_vector3 *p_self, const godot_vector3 *p_b);
|
||||
godot_bool (*godot_vector3_operator_less)(const godot_vector3 *p_self, const godot_vector3 *p_b);
|
||||
godot_vector3 (*godot_vector3_operator_neg)(const godot_vector3 *p_self);
|
||||
void (*godot_vector3_set_axis)(godot_vector3 *p_self, const godot_vector3_axis p_axis, const godot_real p_val);
|
||||
godot_real (*godot_vector3_get_axis)(const godot_vector3 *p_self, const godot_vector3_axis p_axis);
|
||||
void (*godot_pool_byte_array_new)(godot_pool_byte_array *r_dest);
|
||||
void (*godot_pool_byte_array_new_copy)(godot_pool_byte_array *r_dest, const godot_pool_byte_array *p_src);
|
||||
void (*godot_pool_byte_array_new_with_array)(godot_pool_byte_array *r_dest, const godot_array *p_a);
|
||||
void (*godot_pool_byte_array_append)(godot_pool_byte_array *p_self, const uint8_t p_data);
|
||||
void (*godot_pool_byte_array_append_array)(godot_pool_byte_array *p_self, const godot_pool_byte_array *p_array);
|
||||
godot_error (*godot_pool_byte_array_insert)(godot_pool_byte_array *p_self, const godot_int p_idx, const uint8_t p_data);
|
||||
void (*godot_pool_byte_array_invert)(godot_pool_byte_array *p_self);
|
||||
void (*godot_pool_byte_array_push_back)(godot_pool_byte_array *p_self, const uint8_t p_data);
|
||||
void (*godot_pool_byte_array_remove)(godot_pool_byte_array *p_self, const godot_int p_idx);
|
||||
void (*godot_pool_byte_array_resize)(godot_pool_byte_array *p_self, const godot_int p_size);
|
||||
void (*godot_pool_byte_array_set)(godot_pool_byte_array *p_self, const godot_int p_idx, const uint8_t p_data);
|
||||
uint8_t (*godot_pool_byte_array_get)(const godot_pool_byte_array *p_self, const godot_int p_idx);
|
||||
godot_int (*godot_pool_byte_array_size)(const godot_pool_byte_array *p_self);
|
||||
void (*godot_pool_byte_array_destroy)(godot_pool_byte_array *p_self);
|
||||
void (*godot_pool_int_array_new)(godot_pool_int_array *r_dest);
|
||||
void (*godot_pool_int_array_new_copy)(godot_pool_int_array *r_dest, const godot_pool_int_array *p_src);
|
||||
void (*godot_pool_int_array_new_with_array)(godot_pool_int_array *r_dest, const godot_array *p_a);
|
||||
void (*godot_pool_int_array_append)(godot_pool_int_array *p_self, const godot_int p_data);
|
||||
void (*godot_pool_int_array_append_array)(godot_pool_int_array *p_self, const godot_pool_int_array *p_array);
|
||||
godot_error (*godot_pool_int_array_insert)(godot_pool_int_array *p_self, const godot_int p_idx, const godot_int p_data);
|
||||
void (*godot_pool_int_array_invert)(godot_pool_int_array *p_self);
|
||||
void (*godot_pool_int_array_push_back)(godot_pool_int_array *p_self, const godot_int p_data);
|
||||
void (*godot_pool_int_array_remove)(godot_pool_int_array *p_self, const godot_int p_idx);
|
||||
void (*godot_pool_int_array_resize)(godot_pool_int_array *p_self, const godot_int p_size);
|
||||
void (*godot_pool_int_array_set)(godot_pool_int_array *p_self, const godot_int p_idx, const godot_int p_data);
|
||||
godot_int (*godot_pool_int_array_get)(const godot_pool_int_array *p_self, const godot_int p_idx);
|
||||
godot_int (*godot_pool_int_array_size)(const godot_pool_int_array *p_self);
|
||||
void (*godot_pool_int_array_destroy)(godot_pool_int_array *p_self);
|
||||
void (*godot_pool_real_array_new)(godot_pool_real_array *r_dest);
|
||||
void (*godot_pool_real_array_new_copy)(godot_pool_real_array *r_dest, const godot_pool_real_array *p_src);
|
||||
void (*godot_pool_real_array_new_with_array)(godot_pool_real_array *r_dest, const godot_array *p_a);
|
||||
void (*godot_pool_real_array_append)(godot_pool_real_array *p_self, const godot_real p_data);
|
||||
void (*godot_pool_real_array_append_array)(godot_pool_real_array *p_self, const godot_pool_real_array *p_array);
|
||||
godot_error (*godot_pool_real_array_insert)(godot_pool_real_array *p_self, const godot_int p_idx, const godot_real p_data);
|
||||
void (*godot_pool_real_array_invert)(godot_pool_real_array *p_self);
|
||||
void (*godot_pool_real_array_push_back)(godot_pool_real_array *p_self, const godot_real p_data);
|
||||
void (*godot_pool_real_array_remove)(godot_pool_real_array *p_self, const godot_int p_idx);
|
||||
void (*godot_pool_real_array_resize)(godot_pool_real_array *p_self, const godot_int p_size);
|
||||
void (*godot_pool_real_array_set)(godot_pool_real_array *p_self, const godot_int p_idx, const godot_real p_data);
|
||||
godot_real (*godot_pool_real_array_get)(const godot_pool_real_array *p_self, const godot_int p_idx);
|
||||
godot_int (*godot_pool_real_array_size)(const godot_pool_real_array *p_self);
|
||||
void (*godot_pool_real_array_destroy)(godot_pool_real_array *p_self);
|
||||
void (*godot_pool_string_array_new)(godot_pool_string_array *r_dest);
|
||||
void (*godot_pool_string_array_new_copy)(godot_pool_string_array *r_dest, const godot_pool_string_array *p_src);
|
||||
void (*godot_pool_string_array_new_with_array)(godot_pool_string_array *r_dest, const godot_array *p_a);
|
||||
void (*godot_pool_string_array_append)(godot_pool_string_array *p_self, const godot_string *p_data);
|
||||
void (*godot_pool_string_array_append_array)(godot_pool_string_array *p_self, const godot_pool_string_array *p_array);
|
||||
godot_error (*godot_pool_string_array_insert)(godot_pool_string_array *p_self, const godot_int p_idx, const godot_string *p_data);
|
||||
void (*godot_pool_string_array_invert)(godot_pool_string_array *p_self);
|
||||
void (*godot_pool_string_array_push_back)(godot_pool_string_array *p_self, const godot_string *p_data);
|
||||
void (*godot_pool_string_array_remove)(godot_pool_string_array *p_self, const godot_int p_idx);
|
||||
void (*godot_pool_string_array_resize)(godot_pool_string_array *p_self, const godot_int p_size);
|
||||
void (*godot_pool_string_array_set)(godot_pool_string_array *p_self, const godot_int p_idx, const godot_string *p_data);
|
||||
godot_string (*godot_pool_string_array_get)(const godot_pool_string_array *p_self, const godot_int p_idx);
|
||||
godot_int (*godot_pool_string_array_size)(const godot_pool_string_array *p_self);
|
||||
void (*godot_pool_string_array_destroy)(godot_pool_string_array *p_self);
|
||||
void (*godot_pool_vector2_array_new)(godot_pool_vector2_array *r_dest);
|
||||
void (*godot_pool_vector2_array_new_copy)(godot_pool_vector2_array *r_dest, const godot_pool_vector2_array *p_src);
|
||||
void (*godot_pool_vector2_array_new_with_array)(godot_pool_vector2_array *r_dest, const godot_array *p_a);
|
||||
void (*godot_pool_vector2_array_append)(godot_pool_vector2_array *p_self, const godot_vector2 *p_data);
|
||||
void (*godot_pool_vector2_array_append_array)(godot_pool_vector2_array *p_self, const godot_pool_vector2_array *p_array);
|
||||
godot_error (*godot_pool_vector2_array_insert)(godot_pool_vector2_array *p_self, const godot_int p_idx, const godot_vector2 *p_data);
|
||||
void (*godot_pool_vector2_array_invert)(godot_pool_vector2_array *p_self);
|
||||
void (*godot_pool_vector2_array_push_back)(godot_pool_vector2_array *p_self, const godot_vector2 *p_data);
|
||||
void (*godot_pool_vector2_array_remove)(godot_pool_vector2_array *p_self, const godot_int p_idx);
|
||||
void (*godot_pool_vector2_array_resize)(godot_pool_vector2_array *p_self, const godot_int p_size);
|
||||
void (*godot_pool_vector2_array_set)(godot_pool_vector2_array *p_self, const godot_int p_idx, const godot_vector2 *p_data);
|
||||
godot_vector2 (*godot_pool_vector2_array_get)(const godot_pool_vector2_array *p_self, const godot_int p_idx);
|
||||
godot_int (*godot_pool_vector2_array_size)(const godot_pool_vector2_array *p_self);
|
||||
void (*godot_pool_vector2_array_destroy)(godot_pool_vector2_array *p_self);
|
||||
void (*godot_pool_vector3_array_new)(godot_pool_vector3_array *r_dest);
|
||||
void (*godot_pool_vector3_array_new_copy)(godot_pool_vector3_array *r_dest, const godot_pool_vector3_array *p_src);
|
||||
void (*godot_pool_vector3_array_new_with_array)(godot_pool_vector3_array *r_dest, const godot_array *p_a);
|
||||
void (*godot_pool_vector3_array_append)(godot_pool_vector3_array *p_self, const godot_vector3 *p_data);
|
||||
void (*godot_pool_vector3_array_append_array)(godot_pool_vector3_array *p_self, const godot_pool_vector3_array *p_array);
|
||||
godot_error (*godot_pool_vector3_array_insert)(godot_pool_vector3_array *p_self, const godot_int p_idx, const godot_vector3 *p_data);
|
||||
void (*godot_pool_vector3_array_invert)(godot_pool_vector3_array *p_self);
|
||||
void (*godot_pool_vector3_array_push_back)(godot_pool_vector3_array *p_self, const godot_vector3 *p_data);
|
||||
void (*godot_pool_vector3_array_remove)(godot_pool_vector3_array *p_self, const godot_int p_idx);
|
||||
void (*godot_pool_vector3_array_resize)(godot_pool_vector3_array *p_self, const godot_int p_size);
|
||||
void (*godot_pool_vector3_array_set)(godot_pool_vector3_array *p_self, const godot_int p_idx, const godot_vector3 *p_data);
|
||||
godot_vector3 (*godot_pool_vector3_array_get)(const godot_pool_vector3_array *p_self, const godot_int p_idx);
|
||||
godot_int (*godot_pool_vector3_array_size)(const godot_pool_vector3_array *p_self);
|
||||
void (*godot_pool_vector3_array_destroy)(godot_pool_vector3_array *p_self);
|
||||
void (*godot_pool_color_array_new)(godot_pool_color_array *r_dest);
|
||||
void (*godot_pool_color_array_new_copy)(godot_pool_color_array *r_dest, const godot_pool_color_array *p_src);
|
||||
void (*godot_pool_color_array_new_with_array)(godot_pool_color_array *r_dest, const godot_array *p_a);
|
||||
void (*godot_pool_color_array_append)(godot_pool_color_array *p_self, const godot_color *p_data);
|
||||
void (*godot_pool_color_array_append_array)(godot_pool_color_array *p_self, const godot_pool_color_array *p_array);
|
||||
godot_error (*godot_pool_color_array_insert)(godot_pool_color_array *p_self, const godot_int p_idx, const godot_color *p_data);
|
||||
void (*godot_pool_color_array_invert)(godot_pool_color_array *p_self);
|
||||
void (*godot_pool_color_array_push_back)(godot_pool_color_array *p_self, const godot_color *p_data);
|
||||
void (*godot_pool_color_array_remove)(godot_pool_color_array *p_self, const godot_int p_idx);
|
||||
void (*godot_pool_color_array_resize)(godot_pool_color_array *p_self, const godot_int p_size);
|
||||
void (*godot_pool_color_array_set)(godot_pool_color_array *p_self, const godot_int p_idx, const godot_color *p_data);
|
||||
godot_color (*godot_pool_color_array_get)(const godot_pool_color_array *p_self, const godot_int p_idx);
|
||||
godot_int (*godot_pool_color_array_size)(const godot_pool_color_array *p_self);
|
||||
void (*godot_pool_color_array_destroy)(godot_pool_color_array *p_self);
|
||||
void (*godot_array_new)(godot_array *r_dest);
|
||||
void (*godot_array_new_copy)(godot_array *r_dest, const godot_array *p_src);
|
||||
void (*godot_array_new_pool_color_array)(godot_array *r_dest, const godot_pool_color_array *p_pca);
|
||||
void (*godot_array_new_pool_vector3_array)(godot_array *r_dest, const godot_pool_vector3_array *p_pv3a);
|
||||
void (*godot_array_new_pool_vector2_array)(godot_array *r_dest, const godot_pool_vector2_array *p_pv2a);
|
||||
void (*godot_array_new_pool_string_array)(godot_array *r_dest, const godot_pool_string_array *p_psa);
|
||||
void (*godot_array_new_pool_real_array)(godot_array *r_dest, const godot_pool_real_array *p_pra);
|
||||
void (*godot_array_new_pool_int_array)(godot_array *r_dest, const godot_pool_int_array *p_pia);
|
||||
void (*godot_array_new_pool_byte_array)(godot_array *r_dest, const godot_pool_byte_array *p_pba);
|
||||
void (*godot_array_set)(godot_array *p_self, const godot_int p_idx, const godot_variant *p_value);
|
||||
godot_variant (*godot_array_get)(const godot_array *p_self, const godot_int p_idx);
|
||||
godot_variant *(*godot_array_operator_index)(godot_array *p_self, const godot_int p_idx);
|
||||
void (*godot_array_append)(godot_array *p_self, const godot_variant *p_value);
|
||||
void (*godot_array_clear)(godot_array *p_self);
|
||||
godot_int (*godot_array_count)(const godot_array *p_self, const godot_variant *p_value);
|
||||
godot_bool (*godot_array_empty)(const godot_array *p_self);
|
||||
void (*godot_array_erase)(godot_array *p_self, const godot_variant *p_value);
|
||||
godot_variant (*godot_array_front)(const godot_array *p_self);
|
||||
godot_variant (*godot_array_back)(const godot_array *p_self);
|
||||
godot_int (*godot_array_find)(const godot_array *p_self, const godot_variant *p_what, const godot_int p_from);
|
||||
godot_int (*godot_array_find_last)(const godot_array *p_self, const godot_variant *p_what);
|
||||
godot_bool (*godot_array_has)(const godot_array *p_self, const godot_variant *p_value);
|
||||
godot_int (*godot_array_hash)(const godot_array *p_self);
|
||||
void (*godot_array_insert)(godot_array *p_self, const godot_int p_pos, const godot_variant *p_value);
|
||||
void (*godot_array_invert)(godot_array *p_self);
|
||||
godot_variant (*godot_array_pop_back)(godot_array *p_self);
|
||||
godot_variant (*godot_array_pop_front)(godot_array *p_self);
|
||||
void (*godot_array_push_back)(godot_array *p_self, const godot_variant *p_value);
|
||||
void (*godot_array_push_front)(godot_array *p_self, const godot_variant *p_value);
|
||||
void (*godot_array_remove)(godot_array *p_self, const godot_int p_idx);
|
||||
void (*godot_array_resize)(godot_array *p_self, const godot_int p_size);
|
||||
godot_int (*godot_array_rfind)(const godot_array *p_self, const godot_variant *p_what, const godot_int p_from);
|
||||
godot_int (*godot_array_size)(const godot_array *p_self);
|
||||
void (*godot_array_sort)(godot_array *p_self);
|
||||
void (*godot_array_sort_custom)(godot_array *p_self, godot_object *p_obj, const godot_string *p_func);
|
||||
void (*godot_array_destroy)(godot_array *p_self);
|
||||
void (*godot_dictionary_new)(godot_dictionary *r_dest);
|
||||
void (*godot_dictionary_new_copy)(godot_dictionary *r_dest, const godot_dictionary *p_src);
|
||||
void (*godot_dictionary_destroy)(godot_dictionary *p_self);
|
||||
godot_int (*godot_dictionary_size)(const godot_dictionary *p_self);
|
||||
godot_bool (*godot_dictionary_empty)(const godot_dictionary *p_self);
|
||||
void (*godot_dictionary_clear)(godot_dictionary *p_self);
|
||||
godot_bool (*godot_dictionary_has)(const godot_dictionary *p_self, const godot_variant *p_key);
|
||||
godot_bool (*godot_dictionary_has_all)(const godot_dictionary *p_self, const godot_array *p_keys);
|
||||
void (*godot_dictionary_erase)(godot_dictionary *p_self, const godot_variant *p_key);
|
||||
godot_int (*godot_dictionary_hash)(const godot_dictionary *p_self);
|
||||
godot_array (*godot_dictionary_keys)(const godot_dictionary *p_self);
|
||||
godot_array (*godot_dictionary_values)(const godot_dictionary *p_self);
|
||||
godot_variant (*godot_dictionary_get)(const godot_dictionary *p_self, const godot_variant *p_key);
|
||||
void (*godot_dictionary_set)(godot_dictionary *p_self, const godot_variant *p_key, const godot_variant *p_value);
|
||||
godot_variant *(*godot_dictionary_operator_index)(godot_dictionary *p_self, const godot_variant *p_key);
|
||||
godot_variant *(*godot_dictionary_next)(const godot_dictionary *p_self, const godot_variant *p_key);
|
||||
godot_bool (*godot_dictionary_operator_equal)(const godot_dictionary *p_self, const godot_dictionary *p_b);
|
||||
godot_string (*godot_dictionary_to_json)(const godot_dictionary *p_self);
|
||||
void (*godot_node_path_new)(godot_node_path *r_dest, const godot_string *p_from);
|
||||
void (*godot_node_path_new_copy)(godot_node_path *r_dest, const godot_node_path *p_src);
|
||||
void (*godot_node_path_destroy)(godot_node_path *p_self);
|
||||
godot_string (*godot_node_path_as_string)(const godot_node_path *p_self);
|
||||
godot_bool (*godot_node_path_is_absolute)(const godot_node_path *p_self);
|
||||
godot_int (*godot_node_path_get_name_count)(const godot_node_path *p_self);
|
||||
godot_string (*godot_node_path_get_name)(const godot_node_path *p_self, const godot_int p_idx);
|
||||
godot_int (*godot_node_path_get_subname_count)(const godot_node_path *p_self);
|
||||
godot_string (*godot_node_path_get_subname)(const godot_node_path *p_self, const godot_int p_idx);
|
||||
godot_string (*godot_node_path_get_property)(const godot_node_path *p_self);
|
||||
godot_bool (*godot_node_path_is_empty)(const godot_node_path *p_self);
|
||||
godot_bool (*godot_node_path_operator_equal)(const godot_node_path *p_self, const godot_node_path *p_b);
|
||||
void (*godot_plane_new_with_reals)(godot_plane *r_dest, const godot_real p_a, const godot_real p_b, const godot_real p_c, const godot_real p_d);
|
||||
void (*godot_plane_new_with_vectors)(godot_plane *r_dest, const godot_vector3 *p_v1, const godot_vector3 *p_v2, const godot_vector3 *p_v3);
|
||||
void (*godot_plane_new_with_normal)(godot_plane *r_dest, const godot_vector3 *p_normal, const godot_real p_d);
|
||||
godot_string (*godot_plane_as_string)(const godot_plane *p_self);
|
||||
godot_plane (*godot_plane_normalized)(const godot_plane *p_self);
|
||||
godot_vector3 (*godot_plane_center)(const godot_plane *p_self);
|
||||
godot_vector3 (*godot_plane_get_any_point)(const godot_plane *p_self);
|
||||
godot_bool (*godot_plane_is_point_over)(const godot_plane *p_self, const godot_vector3 *p_point);
|
||||
godot_real (*godot_plane_distance_to)(const godot_plane *p_self, const godot_vector3 *p_point);
|
||||
godot_bool (*godot_plane_has_point)(const godot_plane *p_self, const godot_vector3 *p_point, const godot_real p_epsilon);
|
||||
godot_vector3 (*godot_plane_project)(const godot_plane *p_self, const godot_vector3 *p_point);
|
||||
godot_bool (*godot_plane_intersect_3)(const godot_plane *p_self, godot_vector3 *r_dest, const godot_plane *p_b, const godot_plane *p_c);
|
||||
godot_bool (*godot_plane_intersects_ray)(const godot_plane *p_self, godot_vector3 *r_dest, const godot_vector3 *p_from, const godot_vector3 *p_dir);
|
||||
godot_bool (*godot_plane_intersects_segment)(const godot_plane *p_self, godot_vector3 *r_dest, const godot_vector3 *p_begin, const godot_vector3 *p_end);
|
||||
godot_plane (*godot_plane_operator_neg)(const godot_plane *p_self);
|
||||
godot_bool (*godot_plane_operator_equal)(const godot_plane *p_self, const godot_plane *p_b);
|
||||
void (*godot_plane_set_normal)(godot_plane *p_self, const godot_vector3 *p_normal);
|
||||
godot_vector3 (*godot_plane_get_normal)(const godot_plane *p_self);
|
||||
godot_real (*godot_plane_get_d)(const godot_plane *p_self);
|
||||
void (*godot_plane_set_d)(godot_plane *p_self, const godot_real p_d);
|
||||
void (*godot_rect2_new_with_position_and_size)(godot_rect2 *r_dest, const godot_vector2 *p_pos, const godot_vector2 *p_size);
|
||||
void (*godot_rect2_new)(godot_rect2 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_width, const godot_real p_height);
|
||||
godot_string (*godot_rect2_as_string)(const godot_rect2 *p_self);
|
||||
godot_real (*godot_rect2_get_area)(const godot_rect2 *p_self);
|
||||
godot_bool (*godot_rect2_intersects)(const godot_rect2 *p_self, const godot_rect2 *p_b);
|
||||
godot_bool (*godot_rect2_encloses)(const godot_rect2 *p_self, const godot_rect2 *p_b);
|
||||
godot_bool (*godot_rect2_has_no_area)(const godot_rect2 *p_self);
|
||||
godot_rect2 (*godot_rect2_clip)(const godot_rect2 *p_self, const godot_rect2 *p_b);
|
||||
godot_rect2 (*godot_rect2_merge)(const godot_rect2 *p_self, const godot_rect2 *p_b);
|
||||
godot_bool (*godot_rect2_has_point)(const godot_rect2 *p_self, const godot_vector2 *p_point);
|
||||
godot_rect2 (*godot_rect2_grow)(const godot_rect2 *p_self, const godot_real p_by);
|
||||
godot_rect2 (*godot_rect2_expand)(const godot_rect2 *p_self, const godot_vector2 *p_to);
|
||||
godot_bool (*godot_rect2_operator_equal)(const godot_rect2 *p_self, const godot_rect2 *p_b);
|
||||
godot_vector2 (*godot_rect2_get_position)(const godot_rect2 *p_self);
|
||||
godot_vector2 (*godot_rect2_get_size)(const godot_rect2 *p_self);
|
||||
void (*godot_rect2_set_position)(godot_rect2 *p_self, const godot_vector2 *p_pos);
|
||||
void (*godot_rect2_set_size)(godot_rect2 *p_self, const godot_vector2 *p_size);
|
||||
void (*godot_rect3_new)(godot_rect3 *r_dest, const godot_vector3 *p_pos, const godot_vector3 *p_size);
|
||||
godot_vector3 (*godot_rect3_get_position)(const godot_rect3 *p_self);
|
||||
void (*godot_rect3_set_position)(const godot_rect3 *p_self, const godot_vector3 *p_v);
|
||||
godot_vector3 (*godot_rect3_get_size)(const godot_rect3 *p_self);
|
||||
void (*godot_rect3_set_size)(const godot_rect3 *p_self, const godot_vector3 *p_v);
|
||||
godot_string (*godot_rect3_as_string)(const godot_rect3 *p_self);
|
||||
godot_real (*godot_rect3_get_area)(const godot_rect3 *p_self);
|
||||
godot_bool (*godot_rect3_has_no_area)(const godot_rect3 *p_self);
|
||||
godot_bool (*godot_rect3_has_no_surface)(const godot_rect3 *p_self);
|
||||
godot_bool (*godot_rect3_intersects)(const godot_rect3 *p_self, const godot_rect3 *p_with);
|
||||
godot_bool (*godot_rect3_encloses)(const godot_rect3 *p_self, const godot_rect3 *p_with);
|
||||
godot_rect3 (*godot_rect3_merge)(const godot_rect3 *p_self, const godot_rect3 *p_with);
|
||||
godot_rect3 (*godot_rect3_intersection)(const godot_rect3 *p_self, const godot_rect3 *p_with);
|
||||
godot_bool (*godot_rect3_intersects_plane)(const godot_rect3 *p_self, const godot_plane *p_plane);
|
||||
godot_bool (*godot_rect3_intersects_segment)(const godot_rect3 *p_self, const godot_vector3 *p_from, const godot_vector3 *p_to);
|
||||
godot_bool (*godot_rect3_has_point)(const godot_rect3 *p_self, const godot_vector3 *p_point);
|
||||
godot_vector3 (*godot_rect3_get_support)(const godot_rect3 *p_self, const godot_vector3 *p_dir);
|
||||
godot_vector3 (*godot_rect3_get_longest_axis)(const godot_rect3 *p_self);
|
||||
godot_int (*godot_rect3_get_longest_axis_index)(const godot_rect3 *p_self);
|
||||
godot_real (*godot_rect3_get_longest_axis_size)(const godot_rect3 *p_self);
|
||||
godot_vector3 (*godot_rect3_get_shortest_axis)(const godot_rect3 *p_self);
|
||||
godot_int (*godot_rect3_get_shortest_axis_index)(const godot_rect3 *p_self);
|
||||
godot_real (*godot_rect3_get_shortest_axis_size)(const godot_rect3 *p_self);
|
||||
godot_rect3 (*godot_rect3_expand)(const godot_rect3 *p_self, const godot_vector3 *p_to_point);
|
||||
godot_rect3 (*godot_rect3_grow)(const godot_rect3 *p_self, const godot_real p_by);
|
||||
godot_vector3 (*godot_rect3_get_endpoint)(const godot_rect3 *p_self, const godot_int p_idx);
|
||||
godot_bool (*godot_rect3_operator_equal)(const godot_rect3 *p_self, const godot_rect3 *p_b);
|
||||
void (*godot_rid_new)(godot_rid *r_dest);
|
||||
godot_int (*godot_rid_get_id)(const godot_rid *p_self);
|
||||
void (*godot_rid_new_with_resource)(godot_rid *r_dest, const godot_object *p_from);
|
||||
godot_bool (*godot_rid_operator_equal)(const godot_rid *p_self, const godot_rid *p_b);
|
||||
godot_bool (*godot_rid_operator_less)(const godot_rid *p_self, const godot_rid *p_b);
|
||||
void (*godot_transform_new_with_axis_origin)(godot_transform *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis, const godot_vector3 *p_origin);
|
||||
void (*godot_transform_new)(godot_transform *r_dest, const godot_basis *p_basis, const godot_vector3 *p_origin);
|
||||
godot_basis (*godot_transform_get_basis)(const godot_transform *p_self);
|
||||
void (*godot_transform_set_basis)(godot_transform *p_self, godot_basis *p_v);
|
||||
godot_vector3 (*godot_transform_get_origin)(const godot_transform *p_self);
|
||||
void (*godot_transform_set_origin)(godot_transform *p_self, godot_vector3 *p_v);
|
||||
godot_string (*godot_transform_as_string)(const godot_transform *p_self);
|
||||
godot_transform (*godot_transform_inverse)(const godot_transform *p_self);
|
||||
godot_transform (*godot_transform_affine_inverse)(const godot_transform *p_self);
|
||||
godot_transform (*godot_transform_orthonormalized)(const godot_transform *p_self);
|
||||
godot_transform (*godot_transform_rotated)(const godot_transform *p_self, const godot_vector3 *p_axis, const godot_real p_phi);
|
||||
godot_transform (*godot_transform_scaled)(const godot_transform *p_self, const godot_vector3 *p_scale);
|
||||
godot_transform (*godot_transform_translated)(const godot_transform *p_self, const godot_vector3 *p_ofs);
|
||||
godot_transform (*godot_transform_looking_at)(const godot_transform *p_self, const godot_vector3 *p_target, const godot_vector3 *p_up);
|
||||
godot_plane (*godot_transform_xform_plane)(const godot_transform *p_self, const godot_plane *p_v);
|
||||
godot_plane (*godot_transform_xform_inv_plane)(const godot_transform *p_self, const godot_plane *p_v);
|
||||
void (*godot_transform_new_identity)(godot_transform *r_dest);
|
||||
godot_bool (*godot_transform_operator_equal)(const godot_transform *p_self, const godot_transform *p_b);
|
||||
godot_transform (*godot_transform_operator_multiply)(const godot_transform *p_self, const godot_transform *p_b);
|
||||
godot_vector3 (*godot_transform_xform_vector3)(const godot_transform *p_self, const godot_vector3 *p_v);
|
||||
godot_vector3 (*godot_transform_xform_inv_vector3)(const godot_transform *p_self, const godot_vector3 *p_v);
|
||||
godot_rect3 (*godot_transform_xform_rect3)(const godot_transform *p_self, const godot_rect3 *p_v);
|
||||
godot_rect3 (*godot_transform_xform_inv_rect3)(const godot_transform *p_self, const godot_rect3 *p_v);
|
||||
void (*godot_transform2d_new)(godot_transform2d *r_dest, const godot_real p_rot, const godot_vector2 *p_pos);
|
||||
void (*godot_transform2d_new_axis_origin)(godot_transform2d *r_dest, const godot_vector2 *p_x_axis, const godot_vector2 *p_y_axis, const godot_vector2 *p_origin);
|
||||
godot_string (*godot_transform2d_as_string)(const godot_transform2d *p_self);
|
||||
godot_transform2d (*godot_transform2d_inverse)(const godot_transform2d *p_self);
|
||||
godot_transform2d (*godot_transform2d_affine_inverse)(const godot_transform2d *p_self);
|
||||
godot_real (*godot_transform2d_get_rotation)(const godot_transform2d *p_self);
|
||||
godot_vector2 (*godot_transform2d_get_origin)(const godot_transform2d *p_self);
|
||||
godot_vector2 (*godot_transform2d_get_scale)(const godot_transform2d *p_self);
|
||||
godot_transform2d (*godot_transform2d_orthonormalized)(const godot_transform2d *p_self);
|
||||
godot_transform2d (*godot_transform2d_rotated)(const godot_transform2d *p_self, const godot_real p_phi);
|
||||
godot_transform2d (*godot_transform2d_scaled)(const godot_transform2d *p_self, const godot_vector2 *p_scale);
|
||||
godot_transform2d (*godot_transform2d_translated)(const godot_transform2d *p_self, const godot_vector2 *p_offset);
|
||||
godot_vector2 (*godot_transform2d_xform_vector2)(const godot_transform2d *p_self, const godot_vector2 *p_v);
|
||||
godot_vector2 (*godot_transform2d_xform_inv_vector2)(const godot_transform2d *p_self, const godot_vector2 *p_v);
|
||||
godot_vector2 (*godot_transform2d_basis_xform_vector2)(const godot_transform2d *p_self, const godot_vector2 *p_v);
|
||||
godot_vector2 (*godot_transform2d_basis_xform_inv_vector2)(const godot_transform2d *p_self, const godot_vector2 *p_v);
|
||||
godot_transform2d (*godot_transform2d_interpolate_with)(const godot_transform2d *p_self, const godot_transform2d *p_m, const godot_real p_c);
|
||||
godot_bool (*godot_transform2d_operator_equal)(const godot_transform2d *p_self, const godot_transform2d *p_b);
|
||||
godot_transform2d (*godot_transform2d_operator_multiply)(const godot_transform2d *p_self, const godot_transform2d *p_b);
|
||||
void (*godot_transform2d_new_identity)(godot_transform2d *r_dest);
|
||||
godot_rect2 (*godot_transform2d_xform_rect2)(const godot_transform2d *p_self, const godot_rect2 *p_v);
|
||||
godot_rect2 (*godot_transform2d_xform_inv_rect2)(const godot_transform2d *p_self, const godot_rect2 *p_v);
|
||||
godot_variant_type (*godot_variant_get_type)(const godot_variant *p_v);
|
||||
void (*godot_variant_new_copy)(godot_variant *r_dest, const godot_variant *p_src);
|
||||
void (*godot_variant_new_nil)(godot_variant *r_dest);
|
||||
void (*godot_variant_new_bool)(godot_variant *p_v, const godot_bool p_b);
|
||||
void (*godot_variant_new_uint)(godot_variant *r_dest, const uint64_t p_i);
|
||||
void (*godot_variant_new_int)(godot_variant *r_dest, const int64_t p_i);
|
||||
void (*godot_variant_new_real)(godot_variant *r_dest, const double p_r);
|
||||
void (*godot_variant_new_string)(godot_variant *r_dest, const godot_string *p_s);
|
||||
void (*godot_variant_new_vector2)(godot_variant *r_dest, const godot_vector2 *p_v2);
|
||||
void (*godot_variant_new_rect2)(godot_variant *r_dest, const godot_rect2 *p_rect2);
|
||||
void (*godot_variant_new_vector3)(godot_variant *r_dest, const godot_vector3 *p_v3);
|
||||
void (*godot_variant_new_transform2d)(godot_variant *r_dest, const godot_transform2d *p_t2d);
|
||||
void (*godot_variant_new_plane)(godot_variant *r_dest, const godot_plane *p_plane);
|
||||
void (*godot_variant_new_quat)(godot_variant *r_dest, const godot_quat *p_quat);
|
||||
void (*godot_variant_new_rect3)(godot_variant *r_dest, const godot_rect3 *p_rect3);
|
||||
void (*godot_variant_new_basis)(godot_variant *r_dest, const godot_basis *p_basis);
|
||||
void (*godot_variant_new_transform)(godot_variant *r_dest, const godot_transform *p_trans);
|
||||
void (*godot_variant_new_color)(godot_variant *r_dest, const godot_color *p_color);
|
||||
void (*godot_variant_new_node_path)(godot_variant *r_dest, const godot_node_path *p_np);
|
||||
void (*godot_variant_new_rid)(godot_variant *r_dest, const godot_rid *p_rid);
|
||||
void (*godot_variant_new_object)(godot_variant *r_dest, const godot_object *p_obj);
|
||||
void (*godot_variant_new_dictionary)(godot_variant *r_dest, const godot_dictionary *p_dict);
|
||||
void (*godot_variant_new_array)(godot_variant *r_dest, const godot_array *p_arr);
|
||||
void (*godot_variant_new_pool_byte_array)(godot_variant *r_dest, const godot_pool_byte_array *p_pba);
|
||||
void (*godot_variant_new_pool_int_array)(godot_variant *r_dest, const godot_pool_int_array *p_pia);
|
||||
void (*godot_variant_new_pool_real_array)(godot_variant *r_dest, const godot_pool_real_array *p_pra);
|
||||
void (*godot_variant_new_pool_string_array)(godot_variant *r_dest, const godot_pool_string_array *p_psa);
|
||||
void (*godot_variant_new_pool_vector2_array)(godot_variant *r_dest, const godot_pool_vector2_array *p_pv2a);
|
||||
void (*godot_variant_new_pool_vector3_array)(godot_variant *r_dest, const godot_pool_vector3_array *p_pv3a);
|
||||
void (*godot_variant_new_pool_color_array)(godot_variant *r_dest, const godot_pool_color_array *p_pca);
|
||||
godot_bool (*godot_variant_as_bool)(const godot_variant *p_self);
|
||||
uint64_t (*godot_variant_as_uint)(const godot_variant *p_self);
|
||||
int64_t (*godot_variant_as_int)(const godot_variant *p_self);
|
||||
double (*godot_variant_as_real)(const godot_variant *p_self);
|
||||
godot_string (*godot_variant_as_string)(const godot_variant *p_self);
|
||||
godot_vector2 (*godot_variant_as_vector2)(const godot_variant *p_self);
|
||||
godot_rect2 (*godot_variant_as_rect2)(const godot_variant *p_self);
|
||||
godot_vector3 (*godot_variant_as_vector3)(const godot_variant *p_self);
|
||||
godot_transform2d (*godot_variant_as_transform2d)(const godot_variant *p_self);
|
||||
godot_plane (*godot_variant_as_plane)(const godot_variant *p_self);
|
||||
godot_quat (*godot_variant_as_quat)(const godot_variant *p_self);
|
||||
godot_rect3 (*godot_variant_as_rect3)(const godot_variant *p_self);
|
||||
godot_basis (*godot_variant_as_basis)(const godot_variant *p_self);
|
||||
godot_transform (*godot_variant_as_transform)(const godot_variant *p_self);
|
||||
godot_color (*godot_variant_as_color)(const godot_variant *p_self);
|
||||
godot_node_path (*godot_variant_as_node_path)(const godot_variant *p_self);
|
||||
godot_rid (*godot_variant_as_rid)(const godot_variant *p_self);
|
||||
godot_object *(*godot_variant_as_object)(const godot_variant *p_self);
|
||||
godot_dictionary (*godot_variant_as_dictionary)(const godot_variant *p_self);
|
||||
godot_array (*godot_variant_as_array)(const godot_variant *p_self);
|
||||
godot_pool_byte_array (*godot_variant_as_pool_byte_array)(const godot_variant *p_self);
|
||||
godot_pool_int_array (*godot_variant_as_pool_int_array)(const godot_variant *p_self);
|
||||
godot_pool_real_array (*godot_variant_as_pool_real_array)(const godot_variant *p_self);
|
||||
godot_pool_string_array (*godot_variant_as_pool_string_array)(const godot_variant *p_self);
|
||||
godot_pool_vector2_array (*godot_variant_as_pool_vector2_array)(const godot_variant *p_self);
|
||||
godot_pool_vector3_array (*godot_variant_as_pool_vector3_array)(const godot_variant *p_self);
|
||||
godot_pool_color_array (*godot_variant_as_pool_color_array)(const godot_variant *p_self);
|
||||
godot_variant (*godot_variant_call)(godot_variant *p_self, const godot_string *p_method, const godot_variant **p_args, const godot_int p_argcount, godot_variant_call_error *r_error);
|
||||
godot_bool (*godot_variant_has_method)(const godot_variant *p_self, const godot_string *p_method);
|
||||
godot_bool (*godot_variant_operator_equal)(const godot_variant *p_self, const godot_variant *p_other);
|
||||
godot_bool (*godot_variant_operator_less)(const godot_variant *p_self, const godot_variant *p_other);
|
||||
godot_bool (*godot_variant_hash_compare)(const godot_variant *p_self, const godot_variant *p_other);
|
||||
godot_bool (*godot_variant_booleanize)(const godot_variant *p_self);
|
||||
void (*godot_variant_destroy)(godot_variant *p_self);
|
||||
void (*godot_string_new)(godot_string *r_dest);
|
||||
void (*godot_string_new_copy)(godot_string *r_dest, const godot_string *p_src);
|
||||
void (*godot_string_new_data)(godot_string *r_dest, const char *p_contents, const int p_size);
|
||||
void (*godot_string_new_unicode_data)(godot_string *r_dest, const wchar_t *p_contents, const int p_size);
|
||||
void (*godot_string_get_data)(const godot_string *p_self, char *p_dest, int *p_size);
|
||||
wchar_t *(*godot_string_operator_index)(godot_string *p_self, const godot_int p_idx);
|
||||
const char *(*godot_string_c_str)(const godot_string *p_self);
|
||||
const wchar_t *(*godot_string_unicode_str)(const godot_string *p_self);
|
||||
godot_bool (*godot_string_operator_equal)(const godot_string *p_self, const godot_string *p_b);
|
||||
godot_bool (*godot_string_operator_less)(const godot_string *p_self, const godot_string *p_b);
|
||||
godot_string (*godot_string_operator_plus)(const godot_string *p_self, const godot_string *p_b);
|
||||
godot_int (*godot_string_length)(const godot_string *p_self);
|
||||
godot_bool (*godot_string_begins_with)(const godot_string *p_self, const godot_string *p_string);
|
||||
godot_bool (*godot_string_begins_with_char_array)(const godot_string *p_self, const char *p_char_array);
|
||||
godot_array (*godot_string_bigrams)(const godot_string *p_self);
|
||||
godot_string (*godot_string_chr)(wchar_t p_character);
|
||||
godot_bool (*godot_string_ends_with)(const godot_string *p_self, const godot_string *p_string);
|
||||
godot_int (*godot_string_find)(const godot_string *p_self, godot_string p_what);
|
||||
godot_int (*godot_string_find_from)(const godot_string *p_self, godot_string p_what, godot_int p_from);
|
||||
godot_int (*godot_string_findmk)(const godot_string *p_self, const godot_array *p_keys);
|
||||
godot_int (*godot_string_findmk_from)(const godot_string *p_self, const godot_array *p_keys, godot_int p_from);
|
||||
godot_int (*godot_string_findmk_from_in_place)(const godot_string *p_self, const godot_array *p_keys, godot_int p_from, godot_int *r_key);
|
||||
godot_int (*godot_string_findn)(const godot_string *p_self, godot_string p_what);
|
||||
godot_int (*godot_string_findn_from)(const godot_string *p_self, godot_string p_what, godot_int p_from);
|
||||
godot_int (*godot_string_find_last)(const godot_string *p_self, godot_string p_what);
|
||||
godot_string (*godot_string_format)(const godot_string *p_self, const godot_variant *p_values);
|
||||
godot_string (*godot_string_format_with_custom_placeholder)(const godot_string *p_self, const godot_variant *p_values, const char *p_placeholder);
|
||||
godot_string (*godot_string_hex_encode_buffer)(const uint8_t *p_buffer, godot_int p_len);
|
||||
godot_int (*godot_string_hex_to_int)(const godot_string *p_self);
|
||||
godot_int (*godot_string_hex_to_int_without_prefix)(const godot_string *p_self);
|
||||
godot_string (*godot_string_insert)(const godot_string *p_self, godot_int p_at_pos, godot_string p_string);
|
||||
godot_bool (*godot_string_is_numeric)(const godot_string *p_self);
|
||||
godot_bool (*godot_string_is_subsequence_of)(const godot_string *p_self, const godot_string *p_string);
|
||||
godot_bool (*godot_string_is_subsequence_ofi)(const godot_string *p_self, const godot_string *p_string);
|
||||
godot_string (*godot_string_lpad)(const godot_string *p_self, godot_int p_min_length);
|
||||
godot_string (*godot_string_lpad_with_custom_character)(const godot_string *p_self, godot_int p_min_length, const godot_string *p_character);
|
||||
godot_bool (*godot_string_match)(const godot_string *p_self, const godot_string *p_wildcard);
|
||||
godot_bool (*godot_string_matchn)(const godot_string *p_self, const godot_string *p_wildcard);
|
||||
godot_string (*godot_string_md5)(const uint8_t *p_md5);
|
||||
godot_string (*godot_string_num)(double p_num);
|
||||
godot_string (*godot_string_num_int64)(int64_t p_num, godot_int p_base);
|
||||
godot_string (*godot_string_num_int64_capitalized)(int64_t p_num, godot_int p_base, godot_bool p_capitalize_hex);
|
||||
godot_string (*godot_string_num_real)(double p_num);
|
||||
godot_string (*godot_string_num_scientific)(double p_num);
|
||||
godot_string (*godot_string_num_with_decimals)(double p_num, godot_int p_decimals);
|
||||
godot_string (*godot_string_pad_decimals)(const godot_string *p_self, godot_int p_digits);
|
||||
godot_string (*godot_string_pad_zeros)(const godot_string *p_self, godot_int p_digits);
|
||||
godot_string (*godot_string_replace_first)(const godot_string *p_self, godot_string p_key, godot_string p_with);
|
||||
godot_string (*godot_string_replace)(const godot_string *p_self, godot_string p_key, godot_string p_with);
|
||||
godot_string (*godot_string_replacen)(const godot_string *p_self, godot_string p_key, godot_string p_with);
|
||||
godot_int (*godot_string_rfind)(const godot_string *p_self, godot_string p_what);
|
||||
godot_int (*godot_string_rfindn)(const godot_string *p_self, godot_string p_what);
|
||||
godot_int (*godot_string_rfind_from)(const godot_string *p_self, godot_string p_what, godot_int p_from);
|
||||
godot_int (*godot_string_rfindn_from)(const godot_string *p_self, godot_string p_what, godot_int p_from);
|
||||
godot_string (*godot_string_rpad)(const godot_string *p_self, godot_int p_min_length);
|
||||
godot_string (*godot_string_rpad_with_custom_character)(const godot_string *p_self, godot_int p_min_length, const godot_string *p_character);
|
||||
godot_real (*godot_string_similarity)(const godot_string *p_self, const godot_string *p_string);
|
||||
godot_string (*godot_string_sprintf)(const godot_string *p_self, const godot_array *p_values, godot_bool *p_error);
|
||||
godot_string (*godot_string_substr)(const godot_string *p_self, godot_int p_from, godot_int p_chars);
|
||||
double (*godot_string_to_double)(const godot_string *p_self);
|
||||
godot_real (*godot_string_to_float)(const godot_string *p_self);
|
||||
godot_int (*godot_string_to_int)(const godot_string *p_self);
|
||||
godot_string (*godot_string_camelcase_to_underscore)(const godot_string *p_self);
|
||||
godot_string (*godot_string_camelcase_to_underscore_lowercased)(const godot_string *p_self);
|
||||
godot_string (*godot_string_capitalize)(const godot_string *p_self);
|
||||
double (*godot_string_char_to_double)(const char *p_what);
|
||||
godot_int (*godot_string_char_to_int)(const char *p_what);
|
||||
int64_t (*godot_string_wchar_to_int)(const wchar_t *p_str);
|
||||
godot_int (*godot_string_char_to_int_with_len)(const char *p_what, godot_int p_len);
|
||||
int64_t (*godot_string_char_to_int64_with_len)(const wchar_t *p_str, int p_len);
|
||||
int64_t (*godot_string_hex_to_int64)(const godot_string *p_self);
|
||||
int64_t (*godot_string_hex_to_int64_with_prefix)(const godot_string *p_self);
|
||||
int64_t (*godot_string_to_int64)(const godot_string *p_self);
|
||||
double (*godot_string_unicode_char_to_double)(const wchar_t *p_str, const wchar_t **r_end);
|
||||
godot_int (*godot_string_get_slice_count)(const godot_string *p_self, godot_string p_splitter);
|
||||
godot_string (*godot_string_get_slice)(const godot_string *p_self, godot_string p_splitter, godot_int p_slice);
|
||||
godot_string (*godot_string_get_slicec)(const godot_string *p_self, wchar_t p_splitter, godot_int p_slice);
|
||||
godot_array (*godot_string_split)(const godot_string *p_self, const godot_string *p_splitter);
|
||||
godot_array (*godot_string_split_allow_empty)(const godot_string *p_self, const godot_string *p_splitter);
|
||||
godot_array (*godot_string_split_floats)(const godot_string *p_self, const godot_string *p_splitter);
|
||||
godot_array (*godot_string_split_floats_allows_empty)(const godot_string *p_self, const godot_string *p_splitter);
|
||||
godot_array (*godot_string_split_floats_mk)(const godot_string *p_self, const godot_array *p_splitters);
|
||||
godot_array (*godot_string_split_floats_mk_allows_empty)(const godot_string *p_self, const godot_array *p_splitters);
|
||||
godot_array (*godot_string_split_ints)(const godot_string *p_self, const godot_string *p_splitter);
|
||||
godot_array (*godot_string_split_ints_allows_empty)(const godot_string *p_self, const godot_string *p_splitter);
|
||||
godot_array (*godot_string_split_ints_mk)(const godot_string *p_self, const godot_array *p_splitters);
|
||||
godot_array (*godot_string_split_ints_mk_allows_empty)(const godot_string *p_self, const godot_array *p_splitters);
|
||||
godot_array (*godot_string_split_spaces)(const godot_string *p_self);
|
||||
wchar_t (*godot_string_char_lowercase)(wchar_t p_char);
|
||||
wchar_t (*godot_string_char_uppercase)(wchar_t p_char);
|
||||
godot_string (*godot_string_to_lower)(const godot_string *p_self);
|
||||
godot_string (*godot_string_to_upper)(const godot_string *p_self);
|
||||
godot_string (*godot_string_get_basename)(const godot_string *p_self);
|
||||
godot_string (*godot_string_get_extension)(const godot_string *p_self);
|
||||
godot_string (*godot_string_left)(const godot_string *p_self, godot_int p_pos);
|
||||
wchar_t (*godot_string_ord_at)(const godot_string *p_self, godot_int p_idx);
|
||||
godot_string (*godot_string_plus_file)(const godot_string *p_self, const godot_string *p_file);
|
||||
godot_string (*godot_string_right)(const godot_string *p_self, godot_int p_pos);
|
||||
godot_string (*godot_string_strip_edges)(const godot_string *p_self, godot_bool p_left, godot_bool p_right);
|
||||
godot_string (*godot_string_strip_escapes)(const godot_string *p_self);
|
||||
void (*godot_string_erase)(godot_string *p_self, godot_int p_pos, godot_int p_chars);
|
||||
void (*godot_string_ascii)(godot_string *p_self, char *result);
|
||||
void (*godot_string_ascii_extended)(godot_string *p_self, char *result);
|
||||
void (*godot_string_utf8)(godot_string *p_self, char *result);
|
||||
godot_bool (*godot_string_parse_utf8)(godot_string *p_self, const char *p_utf8);
|
||||
godot_bool (*godot_string_parse_utf8_with_len)(godot_string *p_self, const char *p_utf8, godot_int p_len);
|
||||
godot_string (*godot_string_chars_to_utf8)(const char *p_utf8);
|
||||
godot_string (*godot_string_chars_to_utf8_with_len)(const char *p_utf8, godot_int p_len);
|
||||
uint32_t (*godot_string_hash)(const godot_string *p_self);
|
||||
uint64_t (*godot_string_hash64)(const godot_string *p_self);
|
||||
uint32_t (*godot_string_hash_chars)(const char *p_cstr);
|
||||
uint32_t (*godot_string_hash_chars_with_len)(const char *p_cstr, godot_int p_len);
|
||||
uint32_t (*godot_string_hash_utf8_chars)(const wchar_t *p_str);
|
||||
uint32_t (*godot_string_hash_utf8_chars_with_len)(const wchar_t *p_str, godot_int p_len);
|
||||
godot_pool_byte_array (*godot_string_md5_buffer)(const godot_string *p_self);
|
||||
godot_string (*godot_string_md5_text)(const godot_string *p_self);
|
||||
godot_pool_byte_array (*godot_string_sha256_buffer)(const godot_string *p_self);
|
||||
godot_string (*godot_string_sha256_text)(const godot_string *p_self);
|
||||
godot_bool (*godot_string_empty)(const godot_string *p_self);
|
||||
godot_string (*godot_string_get_base_dir)(const godot_string *p_self);
|
||||
godot_string (*godot_string_get_file)(const godot_string *p_self);
|
||||
godot_string (*godot_string_humanize_size)(size_t p_size);
|
||||
godot_bool (*godot_string_is_abs_path)(const godot_string *p_self);
|
||||
godot_bool (*godot_string_is_rel_path)(const godot_string *p_self);
|
||||
godot_bool (*godot_string_is_resource_file)(const godot_string *p_self);
|
||||
godot_string (*godot_string_path_to)(const godot_string *p_self, const godot_string *p_path);
|
||||
godot_string (*godot_string_path_to_file)(const godot_string *p_self, const godot_string *p_path);
|
||||
godot_string (*godot_string_simplify_path)(const godot_string *p_self);
|
||||
godot_string (*godot_string_c_escape)(const godot_string *p_self);
|
||||
godot_string (*godot_string_c_escape_multiline)(const godot_string *p_self);
|
||||
godot_string (*godot_string_c_unescape)(const godot_string *p_self);
|
||||
godot_string (*godot_string_http_escape)(const godot_string *p_self);
|
||||
godot_string (*godot_string_http_unescape)(const godot_string *p_self);
|
||||
godot_string (*godot_string_json_escape)(const godot_string *p_self);
|
||||
godot_string (*godot_string_word_wrap)(const godot_string *p_self, godot_int p_chars_per_line);
|
||||
godot_string (*godot_string_xml_escape)(const godot_string *p_self);
|
||||
godot_string (*godot_string_xml_escape_with_quotes)(const godot_string *p_self);
|
||||
godot_string (*godot_string_xml_unescape)(const godot_string *p_self);
|
||||
godot_string (*godot_string_percent_decode)(const godot_string *p_self);
|
||||
godot_string (*godot_string_percent_encode)(const godot_string *p_self);
|
||||
godot_bool (*godot_string_is_valid_float)(const godot_string *p_self);
|
||||
godot_bool (*godot_string_is_valid_hex_number)(const godot_string *p_self, godot_bool p_with_prefix);
|
||||
godot_bool (*godot_string_is_valid_html_color)(const godot_string *p_self);
|
||||
godot_bool (*godot_string_is_valid_identifier)(const godot_string *p_self);
|
||||
godot_bool (*godot_string_is_valid_integer)(const godot_string *p_self);
|
||||
godot_bool (*godot_string_is_valid_ip_address)(const godot_string *p_self);
|
||||
void (*godot_string_destroy)(godot_string *p_self);
|
||||
void (*godot_string_name_new)(godot_string_name *r_dest, const godot_string *p_name);
|
||||
void (*godot_string_name_new_data)(godot_string_name *r_dest, const char *p_name);
|
||||
godot_string (*godot_string_name_get_name)(const godot_string_name *p_self);
|
||||
uint32_t (*godot_string_name_get_hash)(const godot_string_name *p_self);
|
||||
const void *(*godot_string_name_get_data_unique_pointer)(const godot_string_name *p_self);
|
||||
godot_bool (*godot_string_name_operator_equal)(const godot_string_name *p_self, const godot_string_name *p_other);
|
||||
godot_bool (*godot_string_name_operator_less)(const godot_string_name *p_self, const godot_string_name *p_other);
|
||||
void (*godot_string_name_destroy)(godot_string_name *p_self);
|
||||
void (*godot_object_destroy)(godot_object *p_o);
|
||||
godot_object *(*godot_global_get_singleton)(char *p_name);
|
||||
godot_method_bind *(*godot_method_bind_get_method)(const char *p_classname, const char *p_methodname);
|
||||
void (*godot_method_bind_ptrcall)(godot_method_bind *p_method_bind, godot_object *p_instance, const void **p_args, void *p_ret);
|
||||
godot_variant (*godot_method_bind_call)(godot_method_bind *p_method_bind, godot_object *p_instance, const godot_variant **p_args, const int p_arg_count, godot_variant_call_error *p_call_error);
|
||||
godot_class_constructor (*godot_get_class_constructor)(const char *p_classname);
|
||||
void *(*godot_alloc)(int p_bytes);
|
||||
void *(*godot_realloc)(void *p_ptr, int p_bytes);
|
||||
void (*godot_free)(void *p_ptr);
|
||||
void (*godot_print_error)(const char *p_description, const char *p_function, const char *p_file, int p_line);
|
||||
void (*godot_print_warning)(const char *p_description, const char *p_function, const char *p_file, int p_line);
|
||||
void (*godot_print)(const godot_string *p_message);
|
||||
void (*godot_nativescript_register_class)(void *p_gdnative_handle, const char *p_name, const char *p_base, godot_instance_create_func p_create_func, godot_instance_destroy_func p_destroy_func);
|
||||
void (*godot_nativescript_register_tool_class)(void *p_gdnative_handle, const char *p_name, const char *p_base, godot_instance_create_func p_create_func, godot_instance_destroy_func p_destroy_func);
|
||||
void (*godot_nativescript_register_method)(void *p_gdnative_handle, const char *p_name, const char *p_function_name, godot_method_attributes p_attr, godot_instance_method p_method);
|
||||
void (*godot_nativescript_register_property)(void *p_gdnative_handle, const char *p_name, const char *p_path, godot_property_attributes *p_attr, godot_property_set_func p_set_func, godot_property_get_func p_get_func);
|
||||
void (*godot_nativescript_register_signal)(void *p_gdnative_handle, const char *p_name, const godot_signal *p_signal);
|
||||
void *(*godot_nativescript_get_userdata)(godot_object *p_instance);
|
||||
void (*godot_arvr_register_interface)(const godot_arvr_interface_gdnative *p_interface);
|
||||
godot_real (*godot_arvr_get_worldscale)();
|
||||
godot_transform (*godot_arvr_get_reference_frame)();
|
||||
void (*godot_arvr_blit)(int p_eye, godot_rid *p_render_target, godot_rect2 *p_screen_rect);
|
||||
godot_int (*godot_arvr_get_texid)(godot_rid *p_render_target);
|
||||
godot_int (*godot_arvr_add_controller)(char *p_device_name, godot_int p_hand, godot_bool p_tracks_orientation, godot_bool p_tracks_position);
|
||||
void (*godot_arvr_remove_controller)(godot_int p_controller_id);
|
||||
void (*godot_arvr_set_controller_transform)(godot_int p_controller_id, godot_transform *p_transform, godot_bool p_tracks_orientation, godot_bool p_tracks_position);
|
||||
void (*godot_arvr_set_controller_button)(godot_int p_controller_id, godot_int p_button, godot_bool p_is_pressed);
|
||||
void (*godot_arvr_set_controller_axis)(godot_int p_controller_id, godot_int p_exis, godot_real p_value, godot_bool p_can_be_negative);
|
||||
} godot_gdnative_api_struct;
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // GODOT_GDNATIVE_API_STRUCT_H
|
||||
@@ -1,723 +0,0 @@
|
||||
/*************************************************************************/
|
||||
/* gdnative_api_struct.h */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
#ifndef GODOT_GDNATIVE_API_STRUCT_H
|
||||
#define GODOT_GDNATIVE_API_STRUCT_H
|
||||
|
||||
#include <gdnative/gdnative.h>
|
||||
#include <nativescript/godot_nativescript.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// Using X_MACRO to keep api function signatures in a single list
|
||||
#define GODOT_GDNATIVE_API_FUNCTIONS \
|
||||
GDAPI_FUNC_VOID(godot_color_new_rgba, godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b, const godot_real p_a) \
|
||||
GDAPI_FUNC_VOID(godot_color_new_rgb, godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b) \
|
||||
GDAPI_FUNC(godot_color_get_r, godot_real, const godot_color *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_color_set_r, godot_color *p_self, const godot_real r) \
|
||||
GDAPI_FUNC(godot_color_get_g, godot_real, const godot_color *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_color_set_g, godot_color *p_self, const godot_real g) \
|
||||
GDAPI_FUNC(godot_color_get_b, godot_real, const godot_color *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_color_set_b, godot_color *p_self, const godot_real b) \
|
||||
GDAPI_FUNC(godot_color_get_a, godot_real, const godot_color *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_color_set_a, godot_color *p_self, const godot_real a) \
|
||||
GDAPI_FUNC(godot_color_get_h, godot_real, const godot_color *p_self) \
|
||||
GDAPI_FUNC(godot_color_get_s, godot_real, const godot_color *p_self) \
|
||||
GDAPI_FUNC(godot_color_get_v, godot_real, const godot_color *p_self) \
|
||||
GDAPI_FUNC(godot_color_as_string, godot_string, const godot_color *p_self) \
|
||||
GDAPI_FUNC(godot_color_to_rgba32, godot_int, const godot_color *p_self) \
|
||||
GDAPI_FUNC(godot_color_to_argb32, godot_int, const godot_color *p_self) \
|
||||
GDAPI_FUNC(godot_color_gray, godot_real, const godot_color *p_self) \
|
||||
GDAPI_FUNC(godot_color_inverted, godot_color, const godot_color *p_self) \
|
||||
GDAPI_FUNC(godot_color_contrasted, godot_color, const godot_color *p_self) \
|
||||
GDAPI_FUNC(godot_color_linear_interpolate, godot_color, const godot_color *p_self, const godot_color *p_b, const godot_real p_t) \
|
||||
GDAPI_FUNC(godot_color_blend, godot_color, const godot_color *p_self, const godot_color *p_over) \
|
||||
GDAPI_FUNC(godot_color_to_html, godot_string, const godot_color *p_self, const godot_bool p_with_alpha) \
|
||||
GDAPI_FUNC(godot_color_operator_equal, godot_bool, const godot_color *p_self, const godot_color *p_b) \
|
||||
GDAPI_FUNC(godot_color_operator_less, godot_bool, const godot_color *p_self, const godot_color *p_b) \
|
||||
GDAPI_FUNC_VOID(godot_vector2_new, godot_vector2 *r_dest, const godot_real p_x, const godot_real p_y) \
|
||||
GDAPI_FUNC(godot_vector2_as_string, godot_string, const godot_vector2 *p_self) \
|
||||
GDAPI_FUNC(godot_vector2_normalized, godot_vector2, const godot_vector2 *p_self) \
|
||||
GDAPI_FUNC(godot_vector2_length, godot_real, const godot_vector2 *p_self) \
|
||||
GDAPI_FUNC(godot_vector2_angle, godot_real, const godot_vector2 *p_self) \
|
||||
GDAPI_FUNC(godot_vector2_length_squared, godot_real, const godot_vector2 *p_self) \
|
||||
GDAPI_FUNC(godot_vector2_is_normalized, godot_bool, const godot_vector2 *p_self) \
|
||||
GDAPI_FUNC(godot_vector2_distance_to, godot_real, const godot_vector2 *p_self, const godot_vector2 *p_to) \
|
||||
GDAPI_FUNC(godot_vector2_distance_squared_to, godot_real, const godot_vector2 *p_self, const godot_vector2 *p_to) \
|
||||
GDAPI_FUNC(godot_vector2_angle_to, godot_real, const godot_vector2 *p_self, const godot_vector2 *p_to) \
|
||||
GDAPI_FUNC(godot_vector2_angle_to_point, godot_real, const godot_vector2 *p_self, const godot_vector2 *p_to) \
|
||||
GDAPI_FUNC(godot_vector2_linear_interpolate, godot_vector2, const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_real p_t) \
|
||||
GDAPI_FUNC(godot_vector2_cubic_interpolate, godot_vector2, const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_vector2 *p_pre_a, const godot_vector2 *p_post_b, const godot_real p_t) \
|
||||
GDAPI_FUNC(godot_vector2_rotated, godot_vector2, const godot_vector2 *p_self, const godot_real p_phi) \
|
||||
GDAPI_FUNC(godot_vector2_tangent, godot_vector2, const godot_vector2 *p_self) \
|
||||
GDAPI_FUNC(godot_vector2_floor, godot_vector2, const godot_vector2 *p_self) \
|
||||
GDAPI_FUNC(godot_vector2_snapped, godot_vector2, const godot_vector2 *p_self, const godot_vector2 *p_by) \
|
||||
GDAPI_FUNC(godot_vector2_aspect, godot_real, const godot_vector2 *p_self) \
|
||||
GDAPI_FUNC(godot_vector2_dot, godot_real, const godot_vector2 *p_self, const godot_vector2 *p_with) \
|
||||
GDAPI_FUNC(godot_vector2_slide, godot_vector2, const godot_vector2 *p_self, const godot_vector2 *p_n) \
|
||||
GDAPI_FUNC(godot_vector2_bounce, godot_vector2, const godot_vector2 *p_self, const godot_vector2 *p_n) \
|
||||
GDAPI_FUNC(godot_vector2_reflect, godot_vector2, const godot_vector2 *p_self, const godot_vector2 *p_n) \
|
||||
GDAPI_FUNC(godot_vector2_abs, godot_vector2, const godot_vector2 *p_self) \
|
||||
GDAPI_FUNC(godot_vector2_clamped, godot_vector2, const godot_vector2 *p_self, const godot_real p_length) \
|
||||
GDAPI_FUNC(godot_vector2_operator_add, godot_vector2, const godot_vector2 *p_self, const godot_vector2 *p_b) \
|
||||
GDAPI_FUNC(godot_vector2_operator_substract, godot_vector2, const godot_vector2 *p_self, const godot_vector2 *p_b) \
|
||||
GDAPI_FUNC(godot_vector2_operator_multiply_vector, godot_vector2, const godot_vector2 *p_self, const godot_vector2 *p_b) \
|
||||
GDAPI_FUNC(godot_vector2_operator_multiply_scalar, godot_vector2, const godot_vector2 *p_self, const godot_real p_b) \
|
||||
GDAPI_FUNC(godot_vector2_operator_divide_vector, godot_vector2, const godot_vector2 *p_self, const godot_vector2 *p_b) \
|
||||
GDAPI_FUNC(godot_vector2_operator_divide_scalar, godot_vector2, const godot_vector2 *p_self, const godot_real p_b) \
|
||||
GDAPI_FUNC(godot_vector2_operator_equal, godot_bool, const godot_vector2 *p_self, const godot_vector2 *p_b) \
|
||||
GDAPI_FUNC(godot_vector2_operator_less, godot_bool, const godot_vector2 *p_self, const godot_vector2 *p_b) \
|
||||
GDAPI_FUNC(godot_vector2_operator_neg, godot_vector2, const godot_vector2 *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_vector2_set_x, godot_vector2 *p_self, const godot_real p_x) \
|
||||
GDAPI_FUNC_VOID(godot_vector2_set_y, godot_vector2 *p_self, const godot_real p_y) \
|
||||
GDAPI_FUNC(godot_vector2_get_x, godot_real, const godot_vector2 *p_self) \
|
||||
GDAPI_FUNC(godot_vector2_get_y, godot_real, const godot_vector2 *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_quat_new, godot_quat *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z, const godot_real p_w) \
|
||||
GDAPI_FUNC_VOID(godot_quat_new_with_axis_angle, godot_quat *r_dest, const godot_vector3 *p_axis, const godot_real p_angle) \
|
||||
GDAPI_FUNC(godot_quat_get_x, godot_real, const godot_quat *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_quat_set_x, godot_quat *p_self, const godot_real val) \
|
||||
GDAPI_FUNC(godot_quat_get_y, godot_real, const godot_quat *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_quat_set_y, godot_quat *p_self, const godot_real val) \
|
||||
GDAPI_FUNC(godot_quat_get_z, godot_real, const godot_quat *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_quat_set_z, godot_quat *p_self, const godot_real val) \
|
||||
GDAPI_FUNC(godot_quat_get_w, godot_real, const godot_quat *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_quat_set_w, godot_quat *p_self, const godot_real val) \
|
||||
GDAPI_FUNC(godot_quat_as_string, godot_string, const godot_quat *p_self) \
|
||||
GDAPI_FUNC(godot_quat_length, godot_real, const godot_quat *p_self) \
|
||||
GDAPI_FUNC(godot_quat_length_squared, godot_real, const godot_quat *p_self) \
|
||||
GDAPI_FUNC(godot_quat_normalized, godot_quat, const godot_quat *p_self) \
|
||||
GDAPI_FUNC(godot_quat_is_normalized, godot_bool, const godot_quat *p_self) \
|
||||
GDAPI_FUNC(godot_quat_inverse, godot_quat, const godot_quat *p_self) \
|
||||
GDAPI_FUNC(godot_quat_dot, godot_real, const godot_quat *p_self, const godot_quat *p_b) \
|
||||
GDAPI_FUNC(godot_quat_xform, godot_vector3, const godot_quat *p_self, const godot_vector3 *p_v) \
|
||||
GDAPI_FUNC(godot_quat_slerp, godot_quat, const godot_quat *p_self, const godot_quat *p_b, const godot_real p_t) \
|
||||
GDAPI_FUNC(godot_quat_slerpni, godot_quat, const godot_quat *p_self, const godot_quat *p_b, const godot_real p_t) \
|
||||
GDAPI_FUNC(godot_quat_cubic_slerp, godot_quat, const godot_quat *p_self, const godot_quat *p_b, const godot_quat *p_pre_a, const godot_quat *p_post_b, const godot_real p_t) \
|
||||
GDAPI_FUNC(godot_quat_operator_multiply, godot_quat, const godot_quat *p_self, const godot_real p_b) \
|
||||
GDAPI_FUNC(godot_quat_operator_add, godot_quat, const godot_quat *p_self, const godot_quat *p_b) \
|
||||
GDAPI_FUNC(godot_quat_operator_substract, godot_quat, const godot_quat *p_self, const godot_quat *p_b) \
|
||||
GDAPI_FUNC(godot_quat_operator_divide, godot_quat, const godot_quat *p_self, const godot_real p_b) \
|
||||
GDAPI_FUNC(godot_quat_operator_equal, godot_bool, const godot_quat *p_self, const godot_quat *p_b) \
|
||||
GDAPI_FUNC(godot_quat_operator_neg, godot_quat, const godot_quat *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_basis_new_with_rows, godot_basis *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis) \
|
||||
GDAPI_FUNC_VOID(godot_basis_new_with_axis_and_angle, godot_basis *r_dest, const godot_vector3 *p_axis, const godot_real p_phi) \
|
||||
GDAPI_FUNC_VOID(godot_basis_new_with_euler, godot_basis *r_dest, const godot_vector3 *p_euler) \
|
||||
GDAPI_FUNC(godot_basis_as_string, godot_string, const godot_basis *p_self) \
|
||||
GDAPI_FUNC(godot_basis_inverse, godot_basis, const godot_basis *p_self) \
|
||||
GDAPI_FUNC(godot_basis_transposed, godot_basis, const godot_basis *p_self) \
|
||||
GDAPI_FUNC(godot_basis_orthonormalized, godot_basis, const godot_basis *p_self) \
|
||||
GDAPI_FUNC(godot_basis_determinant, godot_real, const godot_basis *p_self) \
|
||||
GDAPI_FUNC(godot_basis_rotated, godot_basis, const godot_basis *p_self, const godot_vector3 *p_axis, const godot_real p_phi) \
|
||||
GDAPI_FUNC(godot_basis_scaled, godot_basis, const godot_basis *p_self, const godot_vector3 *p_scale) \
|
||||
GDAPI_FUNC(godot_basis_get_scale, godot_vector3, const godot_basis *p_self) \
|
||||
GDAPI_FUNC(godot_basis_get_euler, godot_vector3, const godot_basis *p_self) \
|
||||
GDAPI_FUNC(godot_basis_tdotx, godot_real, const godot_basis *p_self, const godot_vector3 *p_with) \
|
||||
GDAPI_FUNC(godot_basis_tdoty, godot_real, const godot_basis *p_self, const godot_vector3 *p_with) \
|
||||
GDAPI_FUNC(godot_basis_tdotz, godot_real, const godot_basis *p_self, const godot_vector3 *p_with) \
|
||||
GDAPI_FUNC(godot_basis_xform, godot_vector3, const godot_basis *p_self, const godot_vector3 *p_v) \
|
||||
GDAPI_FUNC(godot_basis_xform_inv, godot_vector3, const godot_basis *p_self, const godot_vector3 *p_v) \
|
||||
GDAPI_FUNC(godot_basis_get_orthogonal_index, godot_int, const godot_basis *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_basis_new, godot_basis *r_dest) \
|
||||
GDAPI_FUNC_VOID(godot_basis_new_with_euler_quat, godot_basis *r_dest, const godot_quat *p_euler) \
|
||||
GDAPI_FUNC_VOID(godot_basis_get_elements, godot_basis *p_self, godot_vector3 *p_elements) \
|
||||
GDAPI_FUNC(godot_basis_get_axis, godot_vector3, const godot_basis *p_self, const godot_int p_axis) \
|
||||
GDAPI_FUNC_VOID(godot_basis_set_axis, godot_basis *p_self, const godot_int p_axis, const godot_vector3 *p_value) \
|
||||
GDAPI_FUNC(godot_basis_get_row, godot_vector3, const godot_basis *p_self, const godot_int p_row) \
|
||||
GDAPI_FUNC_VOID(godot_basis_set_row, godot_basis *p_self, const godot_int p_row, const godot_vector3 *p_value) \
|
||||
GDAPI_FUNC(godot_basis_operator_equal, godot_bool, const godot_basis *p_self, const godot_basis *p_b) \
|
||||
GDAPI_FUNC(godot_basis_operator_add, godot_basis, const godot_basis *p_self, const godot_basis *p_b) \
|
||||
GDAPI_FUNC(godot_basis_operator_substract, godot_basis, const godot_basis *p_self, const godot_basis *p_b) \
|
||||
GDAPI_FUNC(godot_basis_operator_multiply_vector, godot_basis, const godot_basis *p_self, const godot_basis *p_b) \
|
||||
GDAPI_FUNC(godot_basis_operator_multiply_scalar, godot_basis, const godot_basis *p_self, const godot_real p_b) \
|
||||
GDAPI_FUNC_VOID(godot_vector3_new, godot_vector3 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z) \
|
||||
GDAPI_FUNC(godot_vector3_as_string, godot_string, const godot_vector3 *p_self) \
|
||||
GDAPI_FUNC(godot_vector3_min_axis, godot_int, const godot_vector3 *p_self) \
|
||||
GDAPI_FUNC(godot_vector3_max_axis, godot_int, const godot_vector3 *p_self) \
|
||||
GDAPI_FUNC(godot_vector3_length, godot_real, const godot_vector3 *p_self) \
|
||||
GDAPI_FUNC(godot_vector3_length_squared, godot_real, const godot_vector3 *p_self) \
|
||||
GDAPI_FUNC(godot_vector3_is_normalized, godot_bool, const godot_vector3 *p_self) \
|
||||
GDAPI_FUNC(godot_vector3_normalized, godot_vector3, const godot_vector3 *p_self) \
|
||||
GDAPI_FUNC(godot_vector3_inverse, godot_vector3, const godot_vector3 *p_self) \
|
||||
GDAPI_FUNC(godot_vector3_snapped, godot_vector3, const godot_vector3 *p_self, const godot_vector3 *p_by) \
|
||||
GDAPI_FUNC(godot_vector3_rotated, godot_vector3, const godot_vector3 *p_self, const godot_vector3 *p_axis, const godot_real p_phi) \
|
||||
GDAPI_FUNC(godot_vector3_linear_interpolate, godot_vector3, const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_real p_t) \
|
||||
GDAPI_FUNC(godot_vector3_cubic_interpolate, godot_vector3, const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_vector3 *p_pre_a, const godot_vector3 *p_post_b, const godot_real p_t) \
|
||||
GDAPI_FUNC(godot_vector3_dot, godot_real, const godot_vector3 *p_self, const godot_vector3 *p_b) \
|
||||
GDAPI_FUNC(godot_vector3_cross, godot_vector3, const godot_vector3 *p_self, const godot_vector3 *p_b) \
|
||||
GDAPI_FUNC(godot_vector3_outer, godot_basis, const godot_vector3 *p_self, const godot_vector3 *p_b) \
|
||||
GDAPI_FUNC(godot_vector3_to_diagonal_matrix, godot_basis, const godot_vector3 *p_self) \
|
||||
GDAPI_FUNC(godot_vector3_abs, godot_vector3, const godot_vector3 *p_self) \
|
||||
GDAPI_FUNC(godot_vector3_floor, godot_vector3, const godot_vector3 *p_self) \
|
||||
GDAPI_FUNC(godot_vector3_ceil, godot_vector3, const godot_vector3 *p_self) \
|
||||
GDAPI_FUNC(godot_vector3_distance_to, godot_real, const godot_vector3 *p_self, const godot_vector3 *p_b) \
|
||||
GDAPI_FUNC(godot_vector3_distance_squared_to, godot_real, const godot_vector3 *p_self, const godot_vector3 *p_b) \
|
||||
GDAPI_FUNC(godot_vector3_angle_to, godot_real, const godot_vector3 *p_self, const godot_vector3 *p_to) \
|
||||
GDAPI_FUNC(godot_vector3_slide, godot_vector3, const godot_vector3 *p_self, const godot_vector3 *p_n) \
|
||||
GDAPI_FUNC(godot_vector3_bounce, godot_vector3, const godot_vector3 *p_self, const godot_vector3 *p_n) \
|
||||
GDAPI_FUNC(godot_vector3_reflect, godot_vector3, const godot_vector3 *p_self, const godot_vector3 *p_n) \
|
||||
GDAPI_FUNC(godot_vector3_operator_add, godot_vector3, const godot_vector3 *p_self, const godot_vector3 *p_b) \
|
||||
GDAPI_FUNC(godot_vector3_operator_substract, godot_vector3, const godot_vector3 *p_self, const godot_vector3 *p_b) \
|
||||
GDAPI_FUNC(godot_vector3_operator_multiply_vector, godot_vector3, const godot_vector3 *p_self, const godot_vector3 *p_b) \
|
||||
GDAPI_FUNC(godot_vector3_operator_multiply_scalar, godot_vector3, const godot_vector3 *p_self, const godot_real p_b) \
|
||||
GDAPI_FUNC(godot_vector3_operator_divide_vector, godot_vector3, const godot_vector3 *p_self, const godot_vector3 *p_b) \
|
||||
GDAPI_FUNC(godot_vector3_operator_divide_scalar, godot_vector3, const godot_vector3 *p_self, const godot_real p_b) \
|
||||
GDAPI_FUNC(godot_vector3_operator_equal, godot_bool, const godot_vector3 *p_self, const godot_vector3 *p_b) \
|
||||
GDAPI_FUNC(godot_vector3_operator_less, godot_bool, const godot_vector3 *p_self, const godot_vector3 *p_b) \
|
||||
GDAPI_FUNC(godot_vector3_operator_neg, godot_vector3, const godot_vector3 *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_vector3_set_axis, godot_vector3 *p_self, const godot_vector3_axis p_axis, const godot_real p_val) \
|
||||
GDAPI_FUNC(godot_vector3_get_axis, godot_real, const godot_vector3 *p_self, const godot_vector3_axis p_axis) \
|
||||
GDAPI_FUNC_VOID(godot_pool_byte_array_new, godot_pool_byte_array *r_dest) \
|
||||
GDAPI_FUNC_VOID(godot_pool_byte_array_new_copy, godot_pool_byte_array *r_dest, const godot_pool_byte_array *p_src) \
|
||||
GDAPI_FUNC_VOID(godot_pool_byte_array_new_with_array, godot_pool_byte_array *r_dest, const godot_array *p_a) \
|
||||
GDAPI_FUNC_VOID(godot_pool_byte_array_append, godot_pool_byte_array *p_self, const uint8_t p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_byte_array_append_array, godot_pool_byte_array *p_self, const godot_pool_byte_array *p_array) \
|
||||
GDAPI_FUNC(godot_pool_byte_array_insert, godot_error, godot_pool_byte_array *p_self, const godot_int p_idx, const uint8_t p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_byte_array_invert, godot_pool_byte_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_byte_array_push_back, godot_pool_byte_array *p_self, const uint8_t p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_byte_array_remove, godot_pool_byte_array *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC_VOID(godot_pool_byte_array_resize, godot_pool_byte_array *p_self, const godot_int p_size) \
|
||||
GDAPI_FUNC_VOID(godot_pool_byte_array_set, godot_pool_byte_array *p_self, const godot_int p_idx, const uint8_t p_data) \
|
||||
GDAPI_FUNC(godot_pool_byte_array_get, uint8_t, const godot_pool_byte_array *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC(godot_pool_byte_array_size, godot_int, const godot_pool_byte_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_byte_array_destroy, godot_pool_byte_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_int_array_new, godot_pool_int_array *r_dest) \
|
||||
GDAPI_FUNC_VOID(godot_pool_int_array_new_copy, godot_pool_int_array *r_dest, const godot_pool_int_array *p_src) \
|
||||
GDAPI_FUNC_VOID(godot_pool_int_array_new_with_array, godot_pool_int_array *r_dest, const godot_array *p_a) \
|
||||
GDAPI_FUNC_VOID(godot_pool_int_array_append, godot_pool_int_array *p_self, const godot_int p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_int_array_append_array, godot_pool_int_array *p_self, const godot_pool_int_array *p_array) \
|
||||
GDAPI_FUNC(godot_pool_int_array_insert, godot_error, godot_pool_int_array *p_self, const godot_int p_idx, const godot_int p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_int_array_invert, godot_pool_int_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_int_array_push_back, godot_pool_int_array *p_self, const godot_int p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_int_array_remove, godot_pool_int_array *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC_VOID(godot_pool_int_array_resize, godot_pool_int_array *p_self, const godot_int p_size) \
|
||||
GDAPI_FUNC_VOID(godot_pool_int_array_set, godot_pool_int_array *p_self, const godot_int p_idx, const godot_int p_data) \
|
||||
GDAPI_FUNC(godot_pool_int_array_get, godot_int, const godot_pool_int_array *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC(godot_pool_int_array_size, godot_int, const godot_pool_int_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_int_array_destroy, godot_pool_int_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_real_array_new, godot_pool_real_array *r_dest) \
|
||||
GDAPI_FUNC_VOID(godot_pool_real_array_new_copy, godot_pool_real_array *r_dest, const godot_pool_real_array *p_src) \
|
||||
GDAPI_FUNC_VOID(godot_pool_real_array_new_with_array, godot_pool_real_array *r_dest, const godot_array *p_a) \
|
||||
GDAPI_FUNC_VOID(godot_pool_real_array_append, godot_pool_real_array *p_self, const godot_real p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_real_array_append_array, godot_pool_real_array *p_self, const godot_pool_real_array *p_array) \
|
||||
GDAPI_FUNC(godot_pool_real_array_insert, godot_error, godot_pool_real_array *p_self, const godot_int p_idx, const godot_real p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_real_array_invert, godot_pool_real_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_real_array_push_back, godot_pool_real_array *p_self, const godot_real p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_real_array_remove, godot_pool_real_array *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC_VOID(godot_pool_real_array_resize, godot_pool_real_array *p_self, const godot_int p_size) \
|
||||
GDAPI_FUNC_VOID(godot_pool_real_array_set, godot_pool_real_array *p_self, const godot_int p_idx, const godot_real p_data) \
|
||||
GDAPI_FUNC(godot_pool_real_array_get, godot_real, const godot_pool_real_array *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC(godot_pool_real_array_size, godot_int, const godot_pool_real_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_real_array_destroy, godot_pool_real_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_string_array_new, godot_pool_string_array *r_dest) \
|
||||
GDAPI_FUNC_VOID(godot_pool_string_array_new_copy, godot_pool_string_array *r_dest, const godot_pool_string_array *p_src) \
|
||||
GDAPI_FUNC_VOID(godot_pool_string_array_new_with_array, godot_pool_string_array *r_dest, const godot_array *p_a) \
|
||||
GDAPI_FUNC_VOID(godot_pool_string_array_append, godot_pool_string_array *p_self, const godot_string *p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_string_array_append_array, godot_pool_string_array *p_self, const godot_pool_string_array *p_array) \
|
||||
GDAPI_FUNC(godot_pool_string_array_insert, godot_error, godot_pool_string_array *p_self, const godot_int p_idx, const godot_string *p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_string_array_invert, godot_pool_string_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_string_array_push_back, godot_pool_string_array *p_self, const godot_string *p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_string_array_remove, godot_pool_string_array *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC_VOID(godot_pool_string_array_resize, godot_pool_string_array *p_self, const godot_int p_size) \
|
||||
GDAPI_FUNC_VOID(godot_pool_string_array_set, godot_pool_string_array *p_self, const godot_int p_idx, const godot_string *p_data) \
|
||||
GDAPI_FUNC(godot_pool_string_array_get, godot_string, const godot_pool_string_array *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC(godot_pool_string_array_size, godot_int, const godot_pool_string_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_string_array_destroy, godot_pool_string_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector2_array_new, godot_pool_vector2_array *r_dest) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector2_array_new_copy, godot_pool_vector2_array *r_dest, const godot_pool_vector2_array *p_src) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector2_array_new_with_array, godot_pool_vector2_array *r_dest, const godot_array *p_a) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector2_array_append, godot_pool_vector2_array *p_self, const godot_vector2 *p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector2_array_append_array, godot_pool_vector2_array *p_self, const godot_pool_vector2_array *p_array) \
|
||||
GDAPI_FUNC(godot_pool_vector2_array_insert, godot_error, godot_pool_vector2_array *p_self, const godot_int p_idx, const godot_vector2 *p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector2_array_invert, godot_pool_vector2_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector2_array_push_back, godot_pool_vector2_array *p_self, const godot_vector2 *p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector2_array_remove, godot_pool_vector2_array *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector2_array_resize, godot_pool_vector2_array *p_self, const godot_int p_size) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector2_array_set, godot_pool_vector2_array *p_self, const godot_int p_idx, const godot_vector2 *p_data) \
|
||||
GDAPI_FUNC(godot_pool_vector2_array_get, godot_vector2, const godot_pool_vector2_array *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC(godot_pool_vector2_array_size, godot_int, const godot_pool_vector2_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector2_array_destroy, godot_pool_vector2_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector3_array_new, godot_pool_vector3_array *r_dest) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector3_array_new_copy, godot_pool_vector3_array *r_dest, const godot_pool_vector3_array *p_src) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector3_array_new_with_array, godot_pool_vector3_array *r_dest, const godot_array *p_a) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector3_array_append, godot_pool_vector3_array *p_self, const godot_vector3 *p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector3_array_append_array, godot_pool_vector3_array *p_self, const godot_pool_vector3_array *p_array) \
|
||||
GDAPI_FUNC(godot_pool_vector3_array_insert, godot_error, godot_pool_vector3_array *p_self, const godot_int p_idx, const godot_vector3 *p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector3_array_invert, godot_pool_vector3_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector3_array_push_back, godot_pool_vector3_array *p_self, const godot_vector3 *p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector3_array_remove, godot_pool_vector3_array *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector3_array_resize, godot_pool_vector3_array *p_self, const godot_int p_size) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector3_array_set, godot_pool_vector3_array *p_self, const godot_int p_idx, const godot_vector3 *p_data) \
|
||||
GDAPI_FUNC(godot_pool_vector3_array_get, godot_vector3, const godot_pool_vector3_array *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC(godot_pool_vector3_array_size, godot_int, const godot_pool_vector3_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_vector3_array_destroy, godot_pool_vector3_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_color_array_new, godot_pool_color_array *r_dest) \
|
||||
GDAPI_FUNC_VOID(godot_pool_color_array_new_copy, godot_pool_color_array *r_dest, const godot_pool_color_array *p_src) \
|
||||
GDAPI_FUNC_VOID(godot_pool_color_array_new_with_array, godot_pool_color_array *r_dest, const godot_array *p_a) \
|
||||
GDAPI_FUNC_VOID(godot_pool_color_array_append, godot_pool_color_array *p_self, const godot_color *p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_color_array_append_array, godot_pool_color_array *p_self, const godot_pool_color_array *p_array) \
|
||||
GDAPI_FUNC(godot_pool_color_array_insert, godot_error, godot_pool_color_array *p_self, const godot_int p_idx, const godot_color *p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_color_array_invert, godot_pool_color_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_color_array_push_back, godot_pool_color_array *p_self, const godot_color *p_data) \
|
||||
GDAPI_FUNC_VOID(godot_pool_color_array_remove, godot_pool_color_array *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC_VOID(godot_pool_color_array_resize, godot_pool_color_array *p_self, const godot_int p_size) \
|
||||
GDAPI_FUNC_VOID(godot_pool_color_array_set, godot_pool_color_array *p_self, const godot_int p_idx, const godot_color *p_data) \
|
||||
GDAPI_FUNC(godot_pool_color_array_get, godot_color, const godot_pool_color_array *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC(godot_pool_color_array_size, godot_int, const godot_pool_color_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_pool_color_array_destroy, godot_pool_color_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_array_new, godot_array *r_dest) \
|
||||
GDAPI_FUNC_VOID(godot_array_new_copy, godot_array *r_dest, const godot_array *p_src) \
|
||||
GDAPI_FUNC_VOID(godot_array_new_pool_color_array, godot_array *r_dest, const godot_pool_color_array *p_pca) \
|
||||
GDAPI_FUNC_VOID(godot_array_new_pool_vector3_array, godot_array *r_dest, const godot_pool_vector3_array *p_pv3a) \
|
||||
GDAPI_FUNC_VOID(godot_array_new_pool_vector2_array, godot_array *r_dest, const godot_pool_vector2_array *p_pv2a) \
|
||||
GDAPI_FUNC_VOID(godot_array_new_pool_string_array, godot_array *r_dest, const godot_pool_string_array *p_psa) \
|
||||
GDAPI_FUNC_VOID(godot_array_new_pool_real_array, godot_array *r_dest, const godot_pool_real_array *p_pra) \
|
||||
GDAPI_FUNC_VOID(godot_array_new_pool_int_array, godot_array *r_dest, const godot_pool_int_array *p_pia) \
|
||||
GDAPI_FUNC_VOID(godot_array_new_pool_byte_array, godot_array *r_dest, const godot_pool_byte_array *p_pba) \
|
||||
GDAPI_FUNC_VOID(godot_array_set, godot_array *p_self, const godot_int p_idx, const godot_variant *p_value) \
|
||||
GDAPI_FUNC(godot_array_get, godot_variant, const godot_array *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC(godot_array_operator_index, godot_variant *, godot_array *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC_VOID(godot_array_append, godot_array *p_self, const godot_variant *p_value) \
|
||||
GDAPI_FUNC_VOID(godot_array_clear, godot_array *p_self) \
|
||||
GDAPI_FUNC(godot_array_count, godot_int, const godot_array *p_self, const godot_variant *p_value) \
|
||||
GDAPI_FUNC(godot_array_empty, godot_bool, const godot_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_array_erase, godot_array *p_self, const godot_variant *p_value) \
|
||||
GDAPI_FUNC(godot_array_front, godot_variant, const godot_array *p_self) \
|
||||
GDAPI_FUNC(godot_array_back, godot_variant, const godot_array *p_self) \
|
||||
GDAPI_FUNC(godot_array_find, godot_int, const godot_array *p_self, const godot_variant *p_what, const godot_int p_from) \
|
||||
GDAPI_FUNC(godot_array_find_last, godot_int, const godot_array *p_self, const godot_variant *p_what) \
|
||||
GDAPI_FUNC(godot_array_has, godot_bool, const godot_array *p_self, const godot_variant *p_value) \
|
||||
GDAPI_FUNC(godot_array_hash, godot_int, const godot_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_array_insert, godot_array *p_self, const godot_int p_pos, const godot_variant *p_value) \
|
||||
GDAPI_FUNC_VOID(godot_array_invert, godot_array *p_self) \
|
||||
GDAPI_FUNC(godot_array_pop_back, godot_variant, godot_array *p_self) \
|
||||
GDAPI_FUNC(godot_array_pop_front, godot_variant, godot_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_array_push_back, godot_array *p_self, const godot_variant *p_value) \
|
||||
GDAPI_FUNC_VOID(godot_array_push_front, godot_array *p_self, const godot_variant *p_value) \
|
||||
GDAPI_FUNC_VOID(godot_array_remove, godot_array *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC_VOID(godot_array_resize, godot_array *p_self, const godot_int p_size) \
|
||||
GDAPI_FUNC(godot_array_rfind, godot_int, const godot_array *p_self, const godot_variant *p_what, const godot_int p_from) \
|
||||
GDAPI_FUNC(godot_array_size, godot_int, const godot_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_array_sort, godot_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_array_sort_custom, godot_array *p_self, godot_object *p_obj, const godot_string *p_func) \
|
||||
GDAPI_FUNC_VOID(godot_array_destroy, godot_array *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_dictionary_new, godot_dictionary *r_dest) \
|
||||
GDAPI_FUNC_VOID(godot_dictionary_new_copy, godot_dictionary *r_dest, const godot_dictionary *p_src) \
|
||||
GDAPI_FUNC_VOID(godot_dictionary_destroy, godot_dictionary *p_self) \
|
||||
GDAPI_FUNC(godot_dictionary_size, godot_int, const godot_dictionary *p_self) \
|
||||
GDAPI_FUNC(godot_dictionary_empty, godot_bool, const godot_dictionary *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_dictionary_clear, godot_dictionary *p_self) \
|
||||
GDAPI_FUNC(godot_dictionary_has, godot_bool, const godot_dictionary *p_self, const godot_variant *p_key) \
|
||||
GDAPI_FUNC(godot_dictionary_has_all, godot_bool, const godot_dictionary *p_self, const godot_array *p_keys) \
|
||||
GDAPI_FUNC_VOID(godot_dictionary_erase, godot_dictionary *p_self, const godot_variant *p_key) \
|
||||
GDAPI_FUNC(godot_dictionary_hash, godot_int, const godot_dictionary *p_self) \
|
||||
GDAPI_FUNC(godot_dictionary_keys, godot_array, const godot_dictionary *p_self) \
|
||||
GDAPI_FUNC(godot_dictionary_values, godot_array, const godot_dictionary *p_self) \
|
||||
GDAPI_FUNC(godot_dictionary_get, godot_variant, const godot_dictionary *p_self, const godot_variant *p_key) \
|
||||
GDAPI_FUNC_VOID(godot_dictionary_set, godot_dictionary *p_self, const godot_variant *p_key, const godot_variant *p_value) \
|
||||
GDAPI_FUNC(godot_dictionary_operator_index, godot_variant *, godot_dictionary *p_self, const godot_variant *p_key) \
|
||||
GDAPI_FUNC(godot_dictionary_next, godot_variant *, const godot_dictionary *p_self, const godot_variant *p_key) \
|
||||
GDAPI_FUNC(godot_dictionary_operator_equal, godot_bool, const godot_dictionary *p_self, const godot_dictionary *p_b) \
|
||||
GDAPI_FUNC(godot_dictionary_to_json, godot_string, const godot_dictionary *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_node_path_new, godot_node_path *r_dest, const godot_string *p_from) \
|
||||
GDAPI_FUNC_VOID(godot_node_path_new_copy, godot_node_path *r_dest, const godot_node_path *p_src) \
|
||||
GDAPI_FUNC_VOID(godot_node_path_destroy, godot_node_path *p_self) \
|
||||
GDAPI_FUNC(godot_node_path_as_string, godot_string, const godot_node_path *p_self) \
|
||||
GDAPI_FUNC(godot_node_path_is_absolute, godot_bool, const godot_node_path *p_self) \
|
||||
GDAPI_FUNC(godot_node_path_get_name_count, godot_int, const godot_node_path *p_self) \
|
||||
GDAPI_FUNC(godot_node_path_get_name, godot_string, const godot_node_path *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC(godot_node_path_get_subname_count, godot_int, const godot_node_path *p_self) \
|
||||
GDAPI_FUNC(godot_node_path_get_subname, godot_string, const godot_node_path *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC(godot_node_path_get_property, godot_string, const godot_node_path *p_self) \
|
||||
GDAPI_FUNC(godot_node_path_is_empty, godot_bool, const godot_node_path *p_self) \
|
||||
GDAPI_FUNC(godot_node_path_operator_equal, godot_bool, const godot_node_path *p_self, const godot_node_path *p_b) \
|
||||
GDAPI_FUNC_VOID(godot_plane_new_with_reals, godot_plane *r_dest, const godot_real p_a, const godot_real p_b, const godot_real p_c, const godot_real p_d) \
|
||||
GDAPI_FUNC_VOID(godot_plane_new_with_vectors, godot_plane *r_dest, const godot_vector3 *p_v1, const godot_vector3 *p_v2, const godot_vector3 *p_v3) \
|
||||
GDAPI_FUNC_VOID(godot_plane_new_with_normal, godot_plane *r_dest, const godot_vector3 *p_normal, const godot_real p_d) \
|
||||
GDAPI_FUNC(godot_plane_as_string, godot_string, const godot_plane *p_self) \
|
||||
GDAPI_FUNC(godot_plane_normalized, godot_plane, const godot_plane *p_self) \
|
||||
GDAPI_FUNC(godot_plane_center, godot_vector3, const godot_plane *p_self) \
|
||||
GDAPI_FUNC(godot_plane_get_any_point, godot_vector3, const godot_plane *p_self) \
|
||||
GDAPI_FUNC(godot_plane_is_point_over, godot_bool, const godot_plane *p_self, const godot_vector3 *p_point) \
|
||||
GDAPI_FUNC(godot_plane_distance_to, godot_real, const godot_plane *p_self, const godot_vector3 *p_point) \
|
||||
GDAPI_FUNC(godot_plane_has_point, godot_bool, const godot_plane *p_self, const godot_vector3 *p_point, const godot_real p_epsilon) \
|
||||
GDAPI_FUNC(godot_plane_project, godot_vector3, const godot_plane *p_self, const godot_vector3 *p_point) \
|
||||
GDAPI_FUNC(godot_plane_intersect_3, godot_bool, const godot_plane *p_self, godot_vector3 *r_dest, const godot_plane *p_b, const godot_plane *p_c) \
|
||||
GDAPI_FUNC(godot_plane_intersects_ray, godot_bool, const godot_plane *p_self, godot_vector3 *r_dest, const godot_vector3 *p_from, const godot_vector3 *p_dir) \
|
||||
GDAPI_FUNC(godot_plane_intersects_segment, godot_bool, const godot_plane *p_self, godot_vector3 *r_dest, const godot_vector3 *p_begin, const godot_vector3 *p_end) \
|
||||
GDAPI_FUNC(godot_plane_operator_neg, godot_plane, const godot_plane *p_self) \
|
||||
GDAPI_FUNC(godot_plane_operator_equal, godot_bool, const godot_plane *p_self, const godot_plane *p_b) \
|
||||
GDAPI_FUNC_VOID(godot_plane_set_normal, godot_plane *p_self, const godot_vector3 *p_normal) \
|
||||
GDAPI_FUNC(godot_plane_get_normal, godot_vector3, const godot_plane *p_self) \
|
||||
GDAPI_FUNC(godot_plane_get_d, godot_real, const godot_plane *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_plane_set_d, godot_plane *p_self, const godot_real p_d) \
|
||||
GDAPI_FUNC_VOID(godot_rect2_new_with_position_and_size, godot_rect2 *r_dest, const godot_vector2 *p_pos, const godot_vector2 *p_size) \
|
||||
GDAPI_FUNC_VOID(godot_rect2_new, godot_rect2 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_width, const godot_real p_height) \
|
||||
GDAPI_FUNC(godot_rect2_as_string, godot_string, const godot_rect2 *p_self) \
|
||||
GDAPI_FUNC(godot_rect2_get_area, godot_real, const godot_rect2 *p_self) \
|
||||
GDAPI_FUNC(godot_rect2_intersects, godot_bool, const godot_rect2 *p_self, const godot_rect2 *p_b) \
|
||||
GDAPI_FUNC(godot_rect2_encloses, godot_bool, const godot_rect2 *p_self, const godot_rect2 *p_b) \
|
||||
GDAPI_FUNC(godot_rect2_has_no_area, godot_bool, const godot_rect2 *p_self) \
|
||||
GDAPI_FUNC(godot_rect2_clip, godot_rect2, const godot_rect2 *p_self, const godot_rect2 *p_b) \
|
||||
GDAPI_FUNC(godot_rect2_merge, godot_rect2, const godot_rect2 *p_self, const godot_rect2 *p_b) \
|
||||
GDAPI_FUNC(godot_rect2_has_point, godot_bool, const godot_rect2 *p_self, const godot_vector2 *p_point) \
|
||||
GDAPI_FUNC(godot_rect2_grow, godot_rect2, const godot_rect2 *p_self, const godot_real p_by) \
|
||||
GDAPI_FUNC(godot_rect2_expand, godot_rect2, const godot_rect2 *p_self, const godot_vector2 *p_to) \
|
||||
GDAPI_FUNC(godot_rect2_operator_equal, godot_bool, const godot_rect2 *p_self, const godot_rect2 *p_b) \
|
||||
GDAPI_FUNC(godot_rect2_get_position, godot_vector2, const godot_rect2 *p_self) \
|
||||
GDAPI_FUNC(godot_rect2_get_size, godot_vector2, const godot_rect2 *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_rect2_set_position, godot_rect2 *p_self, const godot_vector2 *p_pos) \
|
||||
GDAPI_FUNC_VOID(godot_rect2_set_size, godot_rect2 *p_self, const godot_vector2 *p_size) \
|
||||
GDAPI_FUNC_VOID(godot_rect3_new, godot_rect3 *r_dest, const godot_vector3 *p_pos, const godot_vector3 *p_size) \
|
||||
GDAPI_FUNC(godot_rect3_get_position, godot_vector3, const godot_rect3 *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_rect3_set_position, const godot_rect3 *p_self, const godot_vector3 *p_v) \
|
||||
GDAPI_FUNC(godot_rect3_get_size, godot_vector3, const godot_rect3 *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_rect3_set_size, const godot_rect3 *p_self, const godot_vector3 *p_v) \
|
||||
GDAPI_FUNC(godot_rect3_as_string, godot_string, const godot_rect3 *p_self) \
|
||||
GDAPI_FUNC(godot_rect3_get_area, godot_real, const godot_rect3 *p_self) \
|
||||
GDAPI_FUNC(godot_rect3_has_no_area, godot_bool, const godot_rect3 *p_self) \
|
||||
GDAPI_FUNC(godot_rect3_has_no_surface, godot_bool, const godot_rect3 *p_self) \
|
||||
GDAPI_FUNC(godot_rect3_intersects, godot_bool, const godot_rect3 *p_self, const godot_rect3 *p_with) \
|
||||
GDAPI_FUNC(godot_rect3_encloses, godot_bool, const godot_rect3 *p_self, const godot_rect3 *p_with) \
|
||||
GDAPI_FUNC(godot_rect3_merge, godot_rect3, const godot_rect3 *p_self, const godot_rect3 *p_with) \
|
||||
GDAPI_FUNC(godot_rect3_intersection, godot_rect3, const godot_rect3 *p_self, const godot_rect3 *p_with) \
|
||||
GDAPI_FUNC(godot_rect3_intersects_plane, godot_bool, const godot_rect3 *p_self, const godot_plane *p_plane) \
|
||||
GDAPI_FUNC(godot_rect3_intersects_segment, godot_bool, const godot_rect3 *p_self, const godot_vector3 *p_from, const godot_vector3 *p_to) \
|
||||
GDAPI_FUNC(godot_rect3_has_point, godot_bool, const godot_rect3 *p_self, const godot_vector3 *p_point) \
|
||||
GDAPI_FUNC(godot_rect3_get_support, godot_vector3, const godot_rect3 *p_self, const godot_vector3 *p_dir) \
|
||||
GDAPI_FUNC(godot_rect3_get_longest_axis, godot_vector3, const godot_rect3 *p_self) \
|
||||
GDAPI_FUNC(godot_rect3_get_longest_axis_index, godot_int, const godot_rect3 *p_self) \
|
||||
GDAPI_FUNC(godot_rect3_get_longest_axis_size, godot_real, const godot_rect3 *p_self) \
|
||||
GDAPI_FUNC(godot_rect3_get_shortest_axis, godot_vector3, const godot_rect3 *p_self) \
|
||||
GDAPI_FUNC(godot_rect3_get_shortest_axis_index, godot_int, const godot_rect3 *p_self) \
|
||||
GDAPI_FUNC(godot_rect3_get_shortest_axis_size, godot_real, const godot_rect3 *p_self) \
|
||||
GDAPI_FUNC(godot_rect3_expand, godot_rect3, const godot_rect3 *p_self, const godot_vector3 *p_to_point) \
|
||||
GDAPI_FUNC(godot_rect3_grow, godot_rect3, const godot_rect3 *p_self, const godot_real p_by) \
|
||||
GDAPI_FUNC(godot_rect3_get_endpoint, godot_vector3, const godot_rect3 *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC(godot_rect3_operator_equal, godot_bool, const godot_rect3 *p_self, const godot_rect3 *p_b) \
|
||||
GDAPI_FUNC_VOID(godot_rid_new, godot_rid *r_dest) \
|
||||
GDAPI_FUNC(godot_rid_get_id, godot_int, const godot_rid *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_rid_new_with_resource, godot_rid *r_dest, const godot_object *p_from) \
|
||||
GDAPI_FUNC(godot_rid_operator_equal, godot_bool, const godot_rid *p_self, const godot_rid *p_b) \
|
||||
GDAPI_FUNC(godot_rid_operator_less, godot_bool, const godot_rid *p_self, const godot_rid *p_b) \
|
||||
GDAPI_FUNC_VOID(godot_transform_new_with_axis_origin, godot_transform *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis, const godot_vector3 *p_origin) \
|
||||
GDAPI_FUNC_VOID(godot_transform_new, godot_transform *r_dest, const godot_basis *p_basis, const godot_vector3 *p_origin) \
|
||||
GDAPI_FUNC(godot_transform_get_basis, godot_basis, const godot_transform *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_transform_set_basis, godot_transform *p_self, godot_basis *p_v) \
|
||||
GDAPI_FUNC(godot_transform_get_origin, godot_vector3, const godot_transform *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_transform_set_origin, godot_transform *p_self, godot_vector3 *p_v) \
|
||||
GDAPI_FUNC(godot_transform_as_string, godot_string, const godot_transform *p_self) \
|
||||
GDAPI_FUNC(godot_transform_inverse, godot_transform, const godot_transform *p_self) \
|
||||
GDAPI_FUNC(godot_transform_affine_inverse, godot_transform, const godot_transform *p_self) \
|
||||
GDAPI_FUNC(godot_transform_orthonormalized, godot_transform, const godot_transform *p_self) \
|
||||
GDAPI_FUNC(godot_transform_rotated, godot_transform, const godot_transform *p_self, const godot_vector3 *p_axis, const godot_real p_phi) \
|
||||
GDAPI_FUNC(godot_transform_scaled, godot_transform, const godot_transform *p_self, const godot_vector3 *p_scale) \
|
||||
GDAPI_FUNC(godot_transform_translated, godot_transform, const godot_transform *p_self, const godot_vector3 *p_ofs) \
|
||||
GDAPI_FUNC(godot_transform_looking_at, godot_transform, const godot_transform *p_self, const godot_vector3 *p_target, const godot_vector3 *p_up) \
|
||||
GDAPI_FUNC(godot_transform_xform_plane, godot_plane, const godot_transform *p_self, const godot_plane *p_v) \
|
||||
GDAPI_FUNC(godot_transform_xform_inv_plane, godot_plane, const godot_transform *p_self, const godot_plane *p_v) \
|
||||
GDAPI_FUNC_VOID(godot_transform_new_identity, godot_transform *r_dest) \
|
||||
GDAPI_FUNC(godot_transform_operator_equal, godot_bool, const godot_transform *p_self, const godot_transform *p_b) \
|
||||
GDAPI_FUNC(godot_transform_operator_multiply, godot_transform, const godot_transform *p_self, const godot_transform *p_b) \
|
||||
GDAPI_FUNC(godot_transform_xform_vector3, godot_vector3, const godot_transform *p_self, const godot_vector3 *p_v) \
|
||||
GDAPI_FUNC(godot_transform_xform_inv_vector3, godot_vector3, const godot_transform *p_self, const godot_vector3 *p_v) \
|
||||
GDAPI_FUNC(godot_transform_xform_rect3, godot_rect3, const godot_transform *p_self, const godot_rect3 *p_v) \
|
||||
GDAPI_FUNC(godot_transform_xform_inv_rect3, godot_rect3, const godot_transform *p_self, const godot_rect3 *p_v) \
|
||||
GDAPI_FUNC_VOID(godot_transform2d_new, godot_transform2d *r_dest, const godot_real p_rot, const godot_vector2 *p_pos) \
|
||||
GDAPI_FUNC_VOID(godot_transform2d_new_axis_origin, godot_transform2d *r_dest, const godot_vector2 *p_x_axis, const godot_vector2 *p_y_axis, const godot_vector2 *p_origin) \
|
||||
GDAPI_FUNC(godot_transform2d_as_string, godot_string, const godot_transform2d *p_self) \
|
||||
GDAPI_FUNC(godot_transform2d_inverse, godot_transform2d, const godot_transform2d *p_self) \
|
||||
GDAPI_FUNC(godot_transform2d_affine_inverse, godot_transform2d, const godot_transform2d *p_self) \
|
||||
GDAPI_FUNC(godot_transform2d_get_rotation, godot_real, const godot_transform2d *p_self) \
|
||||
GDAPI_FUNC(godot_transform2d_get_origin, godot_vector2, const godot_transform2d *p_self) \
|
||||
GDAPI_FUNC(godot_transform2d_get_scale, godot_vector2, const godot_transform2d *p_self) \
|
||||
GDAPI_FUNC(godot_transform2d_orthonormalized, godot_transform2d, const godot_transform2d *p_self) \
|
||||
GDAPI_FUNC(godot_transform2d_rotated, godot_transform2d, const godot_transform2d *p_self, const godot_real p_phi) \
|
||||
GDAPI_FUNC(godot_transform2d_scaled, godot_transform2d, const godot_transform2d *p_self, const godot_vector2 *p_scale) \
|
||||
GDAPI_FUNC(godot_transform2d_translated, godot_transform2d, const godot_transform2d *p_self, const godot_vector2 *p_offset) \
|
||||
GDAPI_FUNC(godot_transform2d_xform_vector2, godot_vector2, const godot_transform2d *p_self, const godot_vector2 *p_v) \
|
||||
GDAPI_FUNC(godot_transform2d_xform_inv_vector2, godot_vector2, const godot_transform2d *p_self, const godot_vector2 *p_v) \
|
||||
GDAPI_FUNC(godot_transform2d_basis_xform_vector2, godot_vector2, const godot_transform2d *p_self, const godot_vector2 *p_v) \
|
||||
GDAPI_FUNC(godot_transform2d_basis_xform_inv_vector2, godot_vector2, const godot_transform2d *p_self, const godot_vector2 *p_v) \
|
||||
GDAPI_FUNC(godot_transform2d_interpolate_with, godot_transform2d, const godot_transform2d *p_self, const godot_transform2d *p_m, const godot_real p_c) \
|
||||
GDAPI_FUNC(godot_transform2d_operator_equal, godot_bool, const godot_transform2d *p_self, const godot_transform2d *p_b) \
|
||||
GDAPI_FUNC(godot_transform2d_operator_multiply, godot_transform2d, const godot_transform2d *p_self, const godot_transform2d *p_b) \
|
||||
GDAPI_FUNC_VOID(godot_transform2d_new_identity, godot_transform2d *r_dest) \
|
||||
GDAPI_FUNC(godot_transform2d_xform_rect2, godot_rect2, const godot_transform2d *p_self, const godot_rect2 *p_v) \
|
||||
GDAPI_FUNC(godot_transform2d_xform_inv_rect2, godot_rect2, const godot_transform2d *p_self, const godot_rect2 *p_v) \
|
||||
GDAPI_FUNC(godot_variant_get_type, godot_variant_type, const godot_variant *p_v) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_copy, godot_variant *r_dest, const godot_variant *p_src) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_nil, godot_variant *r_dest) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_bool, godot_variant *p_v, const godot_bool p_b) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_uint, godot_variant *r_dest, const uint64_t p_i) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_int, godot_variant *r_dest, const int64_t p_i) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_real, godot_variant *r_dest, const double p_r) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_string, godot_variant *r_dest, const godot_string *p_s) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_vector2, godot_variant *r_dest, const godot_vector2 *p_v2) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_rect2, godot_variant *r_dest, const godot_rect2 *p_rect2) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_vector3, godot_variant *r_dest, const godot_vector3 *p_v3) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_transform2d, godot_variant *r_dest, const godot_transform2d *p_t2d) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_plane, godot_variant *r_dest, const godot_plane *p_plane) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_quat, godot_variant *r_dest, const godot_quat *p_quat) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_rect3, godot_variant *r_dest, const godot_rect3 *p_rect3) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_basis, godot_variant *r_dest, const godot_basis *p_basis) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_transform, godot_variant *r_dest, const godot_transform *p_trans) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_color, godot_variant *r_dest, const godot_color *p_color) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_node_path, godot_variant *r_dest, const godot_node_path *p_np) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_rid, godot_variant *r_dest, const godot_rid *p_rid) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_object, godot_variant *r_dest, const godot_object *p_obj) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_dictionary, godot_variant *r_dest, const godot_dictionary *p_dict) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_array, godot_variant *r_dest, const godot_array *p_arr) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_pool_byte_array, godot_variant *r_dest, const godot_pool_byte_array *p_pba) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_pool_int_array, godot_variant *r_dest, const godot_pool_int_array *p_pia) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_pool_real_array, godot_variant *r_dest, const godot_pool_real_array *p_pra) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_pool_string_array, godot_variant *r_dest, const godot_pool_string_array *p_psa) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_pool_vector2_array, godot_variant *r_dest, const godot_pool_vector2_array *p_pv2a) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_pool_vector3_array, godot_variant *r_dest, const godot_pool_vector3_array *p_pv3a) \
|
||||
GDAPI_FUNC_VOID(godot_variant_new_pool_color_array, godot_variant *r_dest, const godot_pool_color_array *p_pca) \
|
||||
GDAPI_FUNC(godot_variant_as_bool, godot_bool, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_uint, uint64_t, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_int, int64_t, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_real, double, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_string, godot_string, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_vector2, godot_vector2, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_rect2, godot_rect2, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_vector3, godot_vector3, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_transform2d, godot_transform2d, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_plane, godot_plane, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_quat, godot_quat, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_rect3, godot_rect3, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_basis, godot_basis, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_transform, godot_transform, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_color, godot_color, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_node_path, godot_node_path, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_rid, godot_rid, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_object, godot_object *, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_dictionary, godot_dictionary, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_array, godot_array, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_pool_byte_array, godot_pool_byte_array, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_pool_int_array, godot_pool_int_array, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_pool_real_array, godot_pool_real_array, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_pool_string_array, godot_pool_string_array, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_pool_vector2_array, godot_pool_vector2_array, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_pool_vector3_array, godot_pool_vector3_array, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_as_pool_color_array, godot_pool_color_array, const godot_variant *p_self) \
|
||||
GDAPI_FUNC(godot_variant_call, godot_variant, godot_variant *p_self, const godot_string *p_method, const godot_variant **p_args, const godot_int p_argcount, godot_variant_call_error *r_error) \
|
||||
GDAPI_FUNC(godot_variant_has_method, godot_bool, const godot_variant *p_self, const godot_string *p_method) \
|
||||
GDAPI_FUNC(godot_variant_operator_equal, godot_bool, const godot_variant *p_self, const godot_variant *p_other) \
|
||||
GDAPI_FUNC(godot_variant_operator_less, godot_bool, const godot_variant *p_self, const godot_variant *p_other) \
|
||||
GDAPI_FUNC(godot_variant_hash_compare, godot_bool, const godot_variant *p_self, const godot_variant *p_other) \
|
||||
GDAPI_FUNC(godot_variant_booleanize, godot_bool, const godot_variant *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_variant_destroy, godot_variant *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_string_new, godot_string *r_dest) \
|
||||
GDAPI_FUNC_VOID(godot_string_new_copy, godot_string *r_dest, const godot_string *p_src) \
|
||||
GDAPI_FUNC_VOID(godot_string_new_data, godot_string *r_dest, const char *p_contents, const int p_size) \
|
||||
GDAPI_FUNC_VOID(godot_string_new_unicode_data, godot_string *r_dest, const wchar_t *p_contents, const int p_size) \
|
||||
GDAPI_FUNC_VOID(godot_string_get_data, const godot_string *p_self, char *p_dest, int *p_size) \
|
||||
GDAPI_FUNC(godot_string_operator_index, wchar_t *, godot_string *p_self, const godot_int p_idx) \
|
||||
GDAPI_FUNC(godot_string_c_str, const char *, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_unicode_str, const wchar_t *, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_operator_equal, godot_bool, const godot_string *p_self, const godot_string *p_b) \
|
||||
GDAPI_FUNC(godot_string_operator_less, godot_bool, const godot_string *p_self, const godot_string *p_b) \
|
||||
GDAPI_FUNC(godot_string_operator_plus, godot_string, const godot_string *p_self, const godot_string *p_b) \
|
||||
GDAPI_FUNC(godot_string_length, godot_int, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_begins_with, godot_bool, const godot_string *p_self, const godot_string *p_string) \
|
||||
GDAPI_FUNC(godot_string_begins_with_char_array, godot_bool, const godot_string *p_self, const char *p_char_array) \
|
||||
GDAPI_FUNC(godot_string_bigrams, godot_array, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_chr, godot_string, wchar_t p_character) \
|
||||
GDAPI_FUNC(godot_string_ends_with, godot_bool, const godot_string *p_self, const godot_string *p_string) \
|
||||
GDAPI_FUNC(godot_string_find, godot_int, const godot_string *p_self, godot_string p_what) \
|
||||
GDAPI_FUNC(godot_string_find_from, godot_int, const godot_string *p_self, godot_string p_what, godot_int p_from) \
|
||||
GDAPI_FUNC(godot_string_findmk, godot_int, const godot_string *p_self, const godot_array *p_keys) \
|
||||
GDAPI_FUNC(godot_string_findmk_from, godot_int, const godot_string *p_self, const godot_array *p_keys, godot_int p_from) \
|
||||
GDAPI_FUNC(godot_string_findmk_from_in_place, godot_int, const godot_string *p_self, const godot_array *p_keys, godot_int p_from, godot_int *r_key) \
|
||||
GDAPI_FUNC(godot_string_findn, godot_int, const godot_string *p_self, godot_string p_what) \
|
||||
GDAPI_FUNC(godot_string_findn_from, godot_int, const godot_string *p_self, godot_string p_what, godot_int p_from) \
|
||||
GDAPI_FUNC(godot_string_find_last, godot_int, const godot_string *p_self, godot_string p_what) \
|
||||
GDAPI_FUNC(godot_string_format, godot_string, const godot_string *p_self, const godot_variant *p_values) \
|
||||
GDAPI_FUNC(godot_string_format_with_custom_placeholder, godot_string, const godot_string *p_self, const godot_variant *p_values, const char *p_placeholder) \
|
||||
GDAPI_FUNC(godot_string_hex_encode_buffer, godot_string, const uint8_t *p_buffer, godot_int p_len) \
|
||||
GDAPI_FUNC(godot_string_hex_to_int, godot_int, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_hex_to_int_without_prefix, godot_int, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_insert, godot_string, const godot_string *p_self, godot_int p_at_pos, godot_string p_string) \
|
||||
GDAPI_FUNC(godot_string_is_numeric, godot_bool, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_is_subsequence_of, godot_bool, const godot_string *p_self, const godot_string *p_string) \
|
||||
GDAPI_FUNC(godot_string_is_subsequence_ofi, godot_bool, const godot_string *p_self, const godot_string *p_string) \
|
||||
GDAPI_FUNC(godot_string_lpad, godot_string, const godot_string *p_self, godot_int p_min_length) \
|
||||
GDAPI_FUNC(godot_string_lpad_with_custom_character, godot_string, const godot_string *p_self, godot_int p_min_length, const godot_string *p_character) \
|
||||
GDAPI_FUNC(godot_string_match, godot_bool, const godot_string *p_self, const godot_string *p_wildcard) \
|
||||
GDAPI_FUNC(godot_string_matchn, godot_bool, const godot_string *p_self, const godot_string *p_wildcard) \
|
||||
GDAPI_FUNC(godot_string_md5, godot_string, const uint8_t *p_md5) \
|
||||
GDAPI_FUNC(godot_string_num, godot_string, double p_num) \
|
||||
GDAPI_FUNC(godot_string_num_int64, godot_string, int64_t p_num, godot_int p_base) \
|
||||
GDAPI_FUNC(godot_string_num_int64_capitalized, godot_string, int64_t p_num, godot_int p_base, godot_bool p_capitalize_hex) \
|
||||
GDAPI_FUNC(godot_string_num_real, godot_string, double p_num) \
|
||||
GDAPI_FUNC(godot_string_num_scientific, godot_string, double p_num) \
|
||||
GDAPI_FUNC(godot_string_num_with_decimals, godot_string, double p_num, godot_int p_decimals) \
|
||||
GDAPI_FUNC(godot_string_pad_decimals, godot_string, const godot_string *p_self, godot_int p_digits) \
|
||||
GDAPI_FUNC(godot_string_pad_zeros, godot_string, const godot_string *p_self, godot_int p_digits) \
|
||||
GDAPI_FUNC(godot_string_replace_first, godot_string, const godot_string *p_self, godot_string p_key, godot_string p_with) \
|
||||
GDAPI_FUNC(godot_string_replace, godot_string, const godot_string *p_self, godot_string p_key, godot_string p_with) \
|
||||
GDAPI_FUNC(godot_string_replacen, godot_string, const godot_string *p_self, godot_string p_key, godot_string p_with) \
|
||||
GDAPI_FUNC(godot_string_rfind, godot_int, const godot_string *p_self, godot_string p_what) \
|
||||
GDAPI_FUNC(godot_string_rfindn, godot_int, const godot_string *p_self, godot_string p_what) \
|
||||
GDAPI_FUNC(godot_string_rfind_from, godot_int, const godot_string *p_self, godot_string p_what, godot_int p_from) \
|
||||
GDAPI_FUNC(godot_string_rfindn_from, godot_int, const godot_string *p_self, godot_string p_what, godot_int p_from) \
|
||||
GDAPI_FUNC(godot_string_rpad, godot_string, const godot_string *p_self, godot_int p_min_length) \
|
||||
GDAPI_FUNC(godot_string_rpad_with_custom_character, godot_string, const godot_string *p_self, godot_int p_min_length, const godot_string *p_character) \
|
||||
GDAPI_FUNC(godot_string_similarity, godot_real, const godot_string *p_self, const godot_string *p_string) \
|
||||
GDAPI_FUNC(godot_string_sprintf, godot_string, const godot_string *p_self, const godot_array *p_values, godot_bool *p_error) \
|
||||
GDAPI_FUNC(godot_string_substr, godot_string, const godot_string *p_self, godot_int p_from, godot_int p_chars) \
|
||||
GDAPI_FUNC(godot_string_to_double, double, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_to_float, godot_real, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_to_int, godot_int, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_camelcase_to_underscore, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_camelcase_to_underscore_lowercased, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_capitalize, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_char_to_double, double, const char *p_what) \
|
||||
GDAPI_FUNC(godot_string_char_to_int, godot_int, const char *p_what) \
|
||||
GDAPI_FUNC(godot_string_wchar_to_int, int64_t, const wchar_t *p_str) \
|
||||
GDAPI_FUNC(godot_string_char_to_int_with_len, godot_int, const char *p_what, godot_int p_len) \
|
||||
GDAPI_FUNC(godot_string_char_to_int64_with_len, int64_t, const wchar_t *p_str, int p_len) \
|
||||
GDAPI_FUNC(godot_string_hex_to_int64, int64_t, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_hex_to_int64_with_prefix, int64_t, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_to_int64, int64_t, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_unicode_char_to_double, double, const wchar_t *p_str, const wchar_t **r_end) \
|
||||
GDAPI_FUNC(godot_string_get_slice_count, godot_int, const godot_string *p_self, godot_string p_splitter) \
|
||||
GDAPI_FUNC(godot_string_get_slice, godot_string, const godot_string *p_self, godot_string p_splitter, godot_int p_slice) \
|
||||
GDAPI_FUNC(godot_string_get_slicec, godot_string, const godot_string *p_self, wchar_t p_splitter, godot_int p_slice) \
|
||||
GDAPI_FUNC(godot_string_split, godot_array, const godot_string *p_self, const godot_string *p_splitter) \
|
||||
GDAPI_FUNC(godot_string_split_allow_empty, godot_array, const godot_string *p_self, const godot_string *p_splitter) \
|
||||
GDAPI_FUNC(godot_string_split_floats, godot_array, const godot_string *p_self, const godot_string *p_splitter) \
|
||||
GDAPI_FUNC(godot_string_split_floats_allows_empty, godot_array, const godot_string *p_self, const godot_string *p_splitter) \
|
||||
GDAPI_FUNC(godot_string_split_floats_mk, godot_array, const godot_string *p_self, const godot_array *p_splitters) \
|
||||
GDAPI_FUNC(godot_string_split_floats_mk_allows_empty, godot_array, const godot_string *p_self, const godot_array *p_splitters) \
|
||||
GDAPI_FUNC(godot_string_split_ints, godot_array, const godot_string *p_self, const godot_string *p_splitter) \
|
||||
GDAPI_FUNC(godot_string_split_ints_allows_empty, godot_array, const godot_string *p_self, const godot_string *p_splitter) \
|
||||
GDAPI_FUNC(godot_string_split_ints_mk, godot_array, const godot_string *p_self, const godot_array *p_splitters) \
|
||||
GDAPI_FUNC(godot_string_split_ints_mk_allows_empty, godot_array, const godot_string *p_self, const godot_array *p_splitters) \
|
||||
GDAPI_FUNC(godot_string_split_spaces, godot_array, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_char_lowercase, wchar_t, wchar_t p_char) \
|
||||
GDAPI_FUNC(godot_string_char_uppercase, wchar_t, wchar_t p_char) \
|
||||
GDAPI_FUNC(godot_string_to_lower, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_to_upper, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_get_basename, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_get_extension, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_left, godot_string, const godot_string *p_self, godot_int p_pos) \
|
||||
GDAPI_FUNC(godot_string_ord_at, wchar_t, const godot_string *p_self, godot_int p_idx) \
|
||||
GDAPI_FUNC(godot_string_plus_file, godot_string, const godot_string *p_self, const godot_string *p_file) \
|
||||
GDAPI_FUNC(godot_string_right, godot_string, const godot_string *p_self, godot_int p_pos) \
|
||||
GDAPI_FUNC(godot_string_strip_edges, godot_string, const godot_string *p_self, godot_bool p_left, godot_bool p_right) \
|
||||
GDAPI_FUNC(godot_string_strip_escapes, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_string_erase, godot_string *p_self, godot_int p_pos, godot_int p_chars) \
|
||||
GDAPI_FUNC_VOID(godot_string_ascii, godot_string *p_self, char *result) \
|
||||
GDAPI_FUNC_VOID(godot_string_ascii_extended, godot_string *p_self, char *result) \
|
||||
GDAPI_FUNC_VOID(godot_string_utf8, godot_string *p_self, char *result) \
|
||||
GDAPI_FUNC(godot_string_parse_utf8, godot_bool, godot_string *p_self, const char *p_utf8) \
|
||||
GDAPI_FUNC(godot_string_parse_utf8_with_len, godot_bool, godot_string *p_self, const char *p_utf8, godot_int p_len) \
|
||||
GDAPI_FUNC(godot_string_chars_to_utf8, godot_string, const char *p_utf8) \
|
||||
GDAPI_FUNC(godot_string_chars_to_utf8_with_len, godot_string, const char *p_utf8, godot_int p_len) \
|
||||
GDAPI_FUNC(godot_string_hash, uint32_t, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_hash64, uint64_t, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_hash_chars, uint32_t, const char *p_cstr) \
|
||||
GDAPI_FUNC(godot_string_hash_chars_with_len, uint32_t, const char *p_cstr, godot_int p_len) \
|
||||
GDAPI_FUNC(godot_string_hash_utf8_chars, uint32_t, const wchar_t *p_str) \
|
||||
GDAPI_FUNC(godot_string_hash_utf8_chars_with_len, uint32_t, const wchar_t *p_str, godot_int p_len) \
|
||||
GDAPI_FUNC(godot_string_md5_buffer, godot_pool_byte_array, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_md5_text, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_sha256_buffer, godot_pool_byte_array, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_sha256_text, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_empty, godot_bool, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_get_base_dir, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_get_file, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_humanize_size, godot_string, size_t p_size) \
|
||||
GDAPI_FUNC(godot_string_is_abs_path, godot_bool, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_is_rel_path, godot_bool, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_is_resource_file, godot_bool, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_path_to, godot_string, const godot_string *p_self, const godot_string *p_path) \
|
||||
GDAPI_FUNC(godot_string_path_to_file, godot_string, const godot_string *p_self, const godot_string *p_path) \
|
||||
GDAPI_FUNC(godot_string_simplify_path, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_c_escape, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_c_escape_multiline, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_c_unescape, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_http_escape, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_http_unescape, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_json_escape, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_word_wrap, godot_string, const godot_string *p_self, godot_int p_chars_per_line) \
|
||||
GDAPI_FUNC(godot_string_xml_escape, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_xml_escape_with_quotes, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_xml_unescape, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_percent_decode, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_percent_encode, godot_string, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_is_valid_float, godot_bool, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_is_valid_hex_number, godot_bool, const godot_string *p_self, godot_bool p_with_prefix) \
|
||||
GDAPI_FUNC(godot_string_is_valid_html_color, godot_bool, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_is_valid_identifier, godot_bool, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_is_valid_integer, godot_bool, const godot_string *p_self) \
|
||||
GDAPI_FUNC(godot_string_is_valid_ip_address, godot_bool, const godot_string *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_string_destroy, godot_string *p_self) \
|
||||
GDAPI_FUNC_VOID(godot_object_destroy, godot_object *p_o) \
|
||||
GDAPI_FUNC(godot_global_get_singleton, godot_object *, char *p_name) \
|
||||
GDAPI_FUNC(godot_get_stack_bottom, void *) \
|
||||
GDAPI_FUNC(godot_method_bind_get_method, godot_method_bind *, const char *p_classname, const char *p_methodname) \
|
||||
GDAPI_FUNC_VOID(godot_method_bind_ptrcall, godot_method_bind *p_method_bind, godot_object *p_instance, const void **p_args, void *p_ret) \
|
||||
GDAPI_FUNC(godot_method_bind_call, godot_variant, godot_method_bind *p_method_bind, godot_object *p_instance, const godot_variant **p_args, const int p_arg_count, godot_variant_call_error *p_call_error) \
|
||||
GDAPI_FUNC(godot_get_class_constructor, godot_class_constructor, const char *p_classname) \
|
||||
GDAPI_FUNC(godot_get_global_constants, godot_dictionary) \
|
||||
GDAPI_FUNC(godot_alloc, void *, int p_bytes) \
|
||||
GDAPI_FUNC(godot_realloc, void *, void *p_ptr, int p_bytes) \
|
||||
GDAPI_FUNC_VOID(godot_free, void *p_ptr) \
|
||||
GDAPI_FUNC_VOID(godot_print_error, const char *p_description, const char *p_function, const char *p_file, int p_line) \
|
||||
GDAPI_FUNC_VOID(godot_print_warning, const char *p_description, const char *p_function, const char *p_file, int p_line) \
|
||||
GDAPI_FUNC_VOID(godot_print, const godot_string *p_message) \
|
||||
GDAPI_FUNC_VOID(godot_nativescript_register_class, void *p_gdnative_handle, const char *p_name, const char *p_base, godot_instance_create_func p_create_func, godot_instance_destroy_func p_destroy_func) \
|
||||
GDAPI_FUNC_VOID(godot_nativescript_register_tool_class, void *p_gdnative_handle, const char *p_name, const char *p_base, godot_instance_create_func p_create_func, godot_instance_destroy_func p_destroy_func) \
|
||||
GDAPI_FUNC_VOID(godot_nativescript_register_method, void *p_gdnative_handle, const char *p_name, const char *p_function_name, godot_method_attributes p_attr, godot_instance_method p_method) \
|
||||
GDAPI_FUNC_VOID(godot_nativescript_register_property, void *p_gdnative_handle, const char *p_name, const char *p_path, godot_property_attributes *p_attr, godot_property_set_func p_set_func, godot_property_get_func p_get_func) \
|
||||
GDAPI_FUNC_VOID(godot_nativescript_register_signal, void *p_gdnative_handle, const char *p_name, const godot_signal *p_signal) \
|
||||
GDAPI_FUNC(godot_nativescript_get_userdata, void *, godot_object *p_instance)
|
||||
|
||||
#define GDAPI_FUNC(name, ret_type, ...) \
|
||||
ret_type (*name)(__VA_ARGS__);
|
||||
#define GDAPI_FUNC_VOID(name, ...) \
|
||||
void (*name)(__VA_ARGS__);
|
||||
|
||||
typedef struct godot_gdnative_api_struct {
|
||||
GODOT_GDNATIVE_API_FUNCTIONS
|
||||
} godot_gdnative_api_struct;
|
||||
|
||||
#undef GDAPI_FUNC
|
||||
#undef GDAPI_FUNC_VOID
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // GODOT_GDNATIVE_API_STRUCT_H
|
||||
78
nativearvr/godot_nativearvr.h
Normal file
78
nativearvr/godot_nativearvr.h
Normal file
@@ -0,0 +1,78 @@
|
||||
/*************************************************************************/
|
||||
/* godot_nativearvr.h */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
#ifndef GODOT_NATIVEARVR_H
|
||||
#define GODOT_NATIVEARVR_H
|
||||
|
||||
#include <gdnative/gdnative.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
void *(*constructor)(godot_object *);
|
||||
void (*destructor)(void *);
|
||||
godot_string (*get_name)(const void *);
|
||||
godot_int (*get_capabilities)(const void *);
|
||||
godot_bool (*get_anchor_detection_is_enabled)(const void *);
|
||||
void (*set_anchor_detection_is_enabled)(void *, godot_bool);
|
||||
godot_bool (*is_stereo)(const void *);
|
||||
godot_bool (*is_initialized)(const void *);
|
||||
godot_bool (*initialize)(void *);
|
||||
void (*uninitialize)(void *);
|
||||
godot_vector2 (*get_recommended_render_targetsize)(const void *);
|
||||
godot_transform (*get_transform_for_eye)(void *, godot_int, godot_transform *);
|
||||
void (*fill_projection_for_eye)(void *, godot_real *, godot_int, godot_real, godot_real, godot_real);
|
||||
void (*commit_for_eye)(void *, godot_int, godot_rid *, godot_rect2 *);
|
||||
void (*process)(void *);
|
||||
} godot_arvr_interface_gdnative;
|
||||
|
||||
void GDAPI godot_arvr_register_interface(const godot_arvr_interface_gdnative *p_interface);
|
||||
|
||||
// helper functions to access ARVRServer data
|
||||
godot_real GDAPI godot_arvr_get_worldscale();
|
||||
godot_transform GDAPI godot_arvr_get_reference_frame();
|
||||
|
||||
// helper functions for rendering
|
||||
void GDAPI godot_arvr_blit(godot_int p_eye, godot_rid *p_render_target, godot_rect2 *p_rect);
|
||||
godot_int GDAPI godot_arvr_get_texid(godot_rid *p_render_target);
|
||||
|
||||
// helper functions for updating ARVR controllers
|
||||
godot_int GDAPI godot_arvr_add_controller(char *p_device_name, godot_int p_hand, godot_bool p_tracks_orientation, godot_bool p_tracks_position);
|
||||
void GDAPI godot_arvr_remove_controller(godot_int p_controller_id);
|
||||
void GDAPI godot_arvr_set_controller_transform(godot_int p_controller_id, godot_transform *p_transform, godot_bool p_tracks_orientation, godot_bool p_tracks_position);
|
||||
void GDAPI godot_arvr_set_controller_button(godot_int p_controller_id, godot_int p_button, godot_bool p_is_pressed);
|
||||
void GDAPI godot_arvr_set_controller_axis(godot_int p_controller_id, godot_int p_axis, godot_real p_value, godot_bool p_can_be_negative);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* !GODOT_NATIVEARVR_H */
|
||||
@@ -36,42 +36,6 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifdef GDAPI_BUILT_IN
|
||||
#define GDAPI_EXPORT
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
#if defined(GDAPI_EXPORT)
|
||||
#define GDCALLINGCONV
|
||||
#define GDAPI __declspec(dllexport) GDCALLINGCONV
|
||||
#else
|
||||
#define GDCALLINGCONV
|
||||
#define GDAPI __declspec(dllimport) GDCALLINGCONV
|
||||
#endif
|
||||
#elif defined(__APPLE__)
|
||||
#include "TargetConditionals.h"
|
||||
#if TARGET_OS_IPHONE
|
||||
#define GDCALLINGCONV __attribute__((visibility("default")))
|
||||
#define GDAPI GDCALLINGCONV
|
||||
#elif TARGET_OS_MAC
|
||||
#define GDCALLINGCONV __attribute__((sysv_abi))
|
||||
#define GDAPI GDCALLINGCONV
|
||||
#endif
|
||||
#else
|
||||
#define GDCALLINGCONV __attribute__((sysv_abi, visibility("default")))
|
||||
#define GDAPI GDCALLINGCONV
|
||||
#endif
|
||||
|
||||
// This is for libraries *using* the header, NOT GODOT EXPOSING STUFF!!
|
||||
#ifdef _WIN32
|
||||
#define GDN_EXPORT __declspec(dllexport)
|
||||
#else
|
||||
#define GDN_EXPORT
|
||||
#endif
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
typedef enum {
|
||||
GODOT_METHOD_RPC_MODE_DISABLED,
|
||||
GODOT_METHOD_RPC_MODE_REMOTE,
|
||||
|
||||
170
pluginscript/godot_pluginscript.h
Normal file
170
pluginscript/godot_pluginscript.h
Normal file
@@ -0,0 +1,170 @@
|
||||
/*************************************************************************/
|
||||
/* godot_nativescript.h */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
#ifndef GODOT_PLUGINSCRIPT_H
|
||||
#define GODOT_PLUGINSCRIPT_H
|
||||
|
||||
#include <gdnative/gdnative.h>
|
||||
#include <nativescript/godot_nativescript.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef void godot_pluginscript_instance_data;
|
||||
typedef void godot_pluginscript_script_data;
|
||||
typedef void godot_pluginscript_language_data;
|
||||
|
||||
// --- Instance ---
|
||||
|
||||
// TODO: use godot_string_name for faster lookup ?
|
||||
typedef struct {
|
||||
godot_pluginscript_instance_data *(*init)(godot_pluginscript_script_data *p_data, godot_object *p_owner);
|
||||
void (*finish)(godot_pluginscript_instance_data *p_data);
|
||||
|
||||
godot_bool (*set_prop)(godot_pluginscript_instance_data *p_data, const godot_string *p_name, const godot_variant *p_value);
|
||||
godot_bool (*get_prop)(godot_pluginscript_instance_data *p_data, const godot_string *p_name, godot_variant *r_ret);
|
||||
|
||||
godot_variant (*call_method)(godot_pluginscript_instance_data *p_data,
|
||||
const godot_string_name *p_method, const godot_variant **p_args,
|
||||
int p_argcount, godot_variant_call_error *r_error);
|
||||
|
||||
void (*notification)(godot_pluginscript_instance_data *p_data, int p_notification);
|
||||
// TODO: could this rpc mode stuff be moved to the godot_pluginscript_script_manifest ?
|
||||
godot_method_rpc_mode (*get_rpc_mode)(godot_pluginscript_instance_data *p_data, const godot_string *p_method);
|
||||
godot_method_rpc_mode (*get_rset_mode)(godot_pluginscript_instance_data *p_data, const godot_string *p_variable);
|
||||
|
||||
//this is used by script languages that keep a reference counter of their own
|
||||
//you can make make Ref<> not die when it reaches zero, so deleting the reference
|
||||
//depends entirely from the script.
|
||||
// Note: You can set thoses function pointer to NULL if not needed.
|
||||
void (*refcount_incremented)(godot_pluginscript_instance_data *p_data);
|
||||
bool (*refcount_decremented)(godot_pluginscript_instance_data *p_data); // return true if it can die
|
||||
} godot_pluginscript_instance_desc;
|
||||
|
||||
// --- Script ---
|
||||
|
||||
typedef struct {
|
||||
godot_pluginscript_script_data *data;
|
||||
godot_string_name name;
|
||||
godot_bool is_tool;
|
||||
godot_string_name base;
|
||||
|
||||
// Member lines format: {<string>: <int>}
|
||||
godot_dictionary member_lines;
|
||||
// Method info dictionary format
|
||||
// {
|
||||
// name: <string>
|
||||
// args: [<dict:property>]
|
||||
// default_args: [<variant>]
|
||||
// return: <dict:property>
|
||||
// flags: <int>
|
||||
// rpc_mode: <int:godot_method_rpc_mode>
|
||||
// }
|
||||
godot_array methods;
|
||||
// Same format than for methods
|
||||
godot_array signals;
|
||||
// Property info dictionary format
|
||||
// {
|
||||
// name: <string>
|
||||
// type: <int:godot_variant_type>
|
||||
// hint: <int:godot_property_hint>
|
||||
// hint_string: <string>
|
||||
// usage: <int:godot_property_usage_flags>
|
||||
// default_value: <variant>
|
||||
// rset_mode: <int:godot_method_rpc_mode>
|
||||
// }
|
||||
godot_array properties;
|
||||
} godot_pluginscript_script_manifest;
|
||||
|
||||
typedef struct {
|
||||
godot_pluginscript_script_manifest (*init)(godot_pluginscript_language_data *p_data, const godot_string *p_path, const godot_string *p_source, godot_error *r_error);
|
||||
void (*finish)(godot_pluginscript_script_data *p_data);
|
||||
godot_pluginscript_instance_desc instance_desc;
|
||||
} godot_pluginscript_script_desc;
|
||||
|
||||
// --- Language ---
|
||||
|
||||
typedef struct {
|
||||
godot_string_name signature;
|
||||
godot_int call_count;
|
||||
godot_int total_time; // In microseconds
|
||||
godot_int self_time; // In microseconds
|
||||
} godot_pluginscript_profiling_data;
|
||||
|
||||
typedef struct {
|
||||
const char *name;
|
||||
const char *type;
|
||||
const char *extension;
|
||||
const char **recognized_extensions; // NULL terminated array
|
||||
godot_pluginscript_language_data *(*init)();
|
||||
void (*finish)(godot_pluginscript_language_data *p_data);
|
||||
const char **reserved_words; // NULL terminated array
|
||||
const char **comment_delimiters; // NULL terminated array
|
||||
const char **string_delimiters; // NULL terminated array
|
||||
godot_bool has_named_classes;
|
||||
|
||||
godot_string (*get_template_source_code)(godot_pluginscript_language_data *p_data, const godot_string *p_class_name, const godot_string *p_base_class_name);
|
||||
godot_bool (*validate)(godot_pluginscript_language_data *p_data, const godot_string *p_script, int *r_line_error, int *r_col_error, godot_string *r_test_error, const godot_string *p_path, godot_pool_string_array *r_functions);
|
||||
int (*find_function)(godot_pluginscript_language_data *p_data, const godot_string *p_function, const godot_string *p_code); // Can be NULL
|
||||
godot_string (*make_function)(godot_pluginscript_language_data *p_data, const godot_string *p_class, const godot_string *p_name, const godot_pool_string_array *p_args);
|
||||
godot_error (*complete_code)(godot_pluginscript_language_data *p_data, const godot_string *p_code, const godot_string *p_base_path, godot_object *p_owner, godot_array *r_options, godot_bool *r_force, godot_string *r_call_hint);
|
||||
void (*auto_indent_code)(godot_pluginscript_language_data *p_data, godot_string *p_code, int p_from_line, int p_to_line);
|
||||
|
||||
void (*add_global_constant)(godot_pluginscript_language_data *p_data, const godot_string *p_variable, const godot_variant *p_value);
|
||||
godot_string (*debug_get_error)(godot_pluginscript_language_data *p_data);
|
||||
int (*debug_get_stack_level_count)(godot_pluginscript_language_data *p_data);
|
||||
int (*debug_get_stack_level_line)(godot_pluginscript_language_data *p_data, int p_level);
|
||||
godot_string (*debug_get_stack_level_function)(godot_pluginscript_language_data *p_data, int p_level);
|
||||
godot_string (*debug_get_stack_level_source)(godot_pluginscript_language_data *p_data, int p_level);
|
||||
void (*debug_get_stack_level_locals)(godot_pluginscript_language_data *p_data, int p_level, godot_pool_string_array *p_locals, godot_array *p_values, int p_max_subitems, int p_max_depth);
|
||||
void (*debug_get_stack_level_members)(godot_pluginscript_language_data *p_data, int p_level, godot_pool_string_array *p_members, godot_array *p_values, int p_max_subitems, int p_max_depth);
|
||||
void (*debug_get_globals)(godot_pluginscript_language_data *p_data, godot_pool_string_array *p_locals, godot_array *p_values, int p_max_subitems, int p_max_depth);
|
||||
godot_string (*debug_parse_stack_level_expression)(godot_pluginscript_language_data *p_data, int p_level, const godot_string *p_expression, int p_max_subitems, int p_max_depth);
|
||||
|
||||
// TODO: could this stuff be moved to the godot_pluginscript_language_desc ?
|
||||
void (*get_public_functions)(godot_pluginscript_language_data *p_data, godot_array *r_functions);
|
||||
void (*get_public_constants)(godot_pluginscript_language_data *p_data, godot_dictionary *r_constants);
|
||||
|
||||
void (*profiling_start)(godot_pluginscript_language_data *p_data);
|
||||
void (*profiling_stop)(godot_pluginscript_language_data *p_data);
|
||||
int (*profiling_get_accumulated_data)(godot_pluginscript_language_data *p_data, godot_pluginscript_profiling_data *r_info, int p_info_max);
|
||||
int (*profiling_get_frame_data)(godot_pluginscript_language_data *p_data, godot_pluginscript_profiling_data *r_info, int p_info_max);
|
||||
void (*profiling_frame)(godot_pluginscript_language_data *p_data);
|
||||
|
||||
godot_pluginscript_script_desc script_desc;
|
||||
} godot_pluginscript_language_desc;
|
||||
|
||||
void GDAPI godot_pluginscript_register_language(const godot_pluginscript_language_desc *language_desc);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // GODOT_PLUGINSCRIPT_H
|
||||
Reference in New Issue
Block a user