1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
/* godot-cpp integration testing project.
*
* This is free and unencumbered software released into the public domain.
*/
#ifndef EXAMPLE_CLASS_H
#define EXAMPLE_CLASS_H
// We don't need windows.h in this example plugin but many others do, and it can
// lead to annoying situations due to the ton of macros it defines.
// So we include it and make sure CI warns us if we use something that conflicts
// with a Windows define.
#ifdef WIN32
#include <windows.h>
#endif
#include <godot_cpp/classes/control.hpp>
#include <godot_cpp/classes/global_constants.hpp>
#include <godot_cpp/classes/image.hpp>
#include <godot_cpp/classes/input_event_key.hpp>
#include <godot_cpp/classes/tile_map.hpp>
#include <godot_cpp/classes/tile_set.hpp>
#include <godot_cpp/classes/viewport.hpp>
#include <godot_cpp/variant/variant.hpp>
#include <godot_cpp/core/binder_common.hpp>
using namespace godot;
class ExampleRef : public RefCounted {
GDCLASS(ExampleRef, RefCounted);
private:
static int instance_count;
static int last_id;
int id;
protected:
static void _bind_methods();
public:
ExampleRef();
~ExampleRef();
void set_id(int p_id);
int get_id() const;
};
class ExampleMin : public Control {
GDCLASS(ExampleMin, Control);
protected:
static void _bind_methods(){};
};
class Example : public Control {
GDCLASS(Example, Control);
protected:
static void _bind_methods();
void _notification(int p_what);
bool _set(const StringName &p_name, const Variant &p_value);
bool _get(const StringName &p_name, Variant &r_ret) const;
void _get_property_list(List<PropertyInfo> *p_list) const;
bool _property_can_revert(const StringName &p_name) const;
bool _property_get_revert(const StringName &p_name, Variant &r_property) const;
void _validate_property(PropertyInfo &p_property) const;
String _to_string() const;
private:
Vector2 custom_position;
Vector3 property_from_list;
Vector2 dprop[3];
int last_rpc_arg = 0;
public:
// Constants.
enum Constants {
FIRST,
ANSWER_TO_EVERYTHING = 42,
};
enum Flags {
FLAG_ONE = 1,
FLAG_TWO = 2,
};
enum {
CONSTANT_WITHOUT_ENUM = 314,
};
Example();
~Example();
// Functions.
void simple_func();
void simple_const_func() const;
int custom_ref_func(Ref<ExampleRef> p_ref);
int custom_const_ref_func(const Ref<ExampleRef> &p_ref);
String image_ref_func(Ref<Image> p_image);
String image_const_ref_func(const Ref<Image> &p_image);
String return_something(const String &base);
Viewport *return_something_const() const;
Ref<ExampleRef> return_ref() const;
Ref<ExampleRef> return_empty_ref() const;
ExampleRef *return_extended_ref() const;
Ref<ExampleRef> extended_ref_checks(Ref<ExampleRef> p_ref) const;
Variant varargs_func(const Variant **args, GDExtensionInt arg_count, GDExtensionCallError &error);
int varargs_func_nv(const Variant **args, GDExtensionInt arg_count, GDExtensionCallError &error);
void varargs_func_void(const Variant **args, GDExtensionInt arg_count, GDExtensionCallError &error);
void emit_custom_signal(const String &name, int value);
int def_args(int p_a = 100, int p_b = 200);
Array test_array() const;
int test_tarray_arg(const TypedArray<int64_t> &p_array);
TypedArray<Vector2> test_tarray() const;
Dictionary test_dictionary() const;
Example *test_node_argument(Example *p_node) const;
String test_string_ops() const;
String test_str_utility() const;
bool test_string_is_fourty_two(const String &p_str) const;
String test_string_resize(String p_original) const;
int test_vector_ops() const;
bool test_object_cast_to_node(Object *p_object) const;
bool test_object_cast_to_control(Object *p_object) const;
bool test_object_cast_to_example(Object *p_object) const;
Vector2i test_variant_vector2i_conversion(const Variant &p_variant) const;
int test_variant_int_conversion(const Variant &p_variant) const;
float test_variant_float_conversion(const Variant &p_variant) const;
void test_add_child(Node *p_node);
void test_set_tileset(TileMap *p_tilemap, const Ref<TileSet> &p_tileset) const;
Variant test_variant_call(Variant p_variant);
Callable test_callable_mp();
Callable test_callable_mp_ret();
Callable test_callable_mp_retc() const;
Callable test_callable_mp_static() const;
Callable test_callable_mp_static_ret() const;
void unbound_method1(Object *p_object, String p_string, int p_int);
String unbound_method2(Object *p_object, String p_string, int p_int);
String unbound_method3(Object *p_object, String p_string, int p_int) const;
static void unbound_static_method1(Example *p_object, String p_string, int p_int);
static String unbound_static_method2(Object *p_object, String p_string, int p_int);
BitField<Flags> test_bitfield(BitField<Flags> flags);
Variant test_variant_iterator(const Variant &p_input);
// RPC
void test_rpc(int p_value);
void test_send_rpc(int p_value);
int return_last_rpc_arg();
// Property.
void set_custom_position(const Vector2 &pos);
Vector2 get_custom_position() const;
Vector4 get_v4() const;
// Static method.
static int test_static(int p_a, int p_b);
static void test_static2();
// Virtual function override (no need to bind manually).
virtual bool _has_point(const Vector2 &point) const override;
virtual void _input(const Ref<InputEvent> &event) override;
};
VARIANT_ENUM_CAST(Example::Constants);
VARIANT_BITFIELD_CAST(Example::Flags);
enum EnumWithoutClass {
OUTSIDE_OF_CLASS = 512
};
VARIANT_ENUM_CAST(EnumWithoutClass);
class ExampleVirtual : public Object {
GDCLASS(ExampleVirtual, Object);
protected:
static void _bind_methods() {}
};
class ExampleAbstract : public Object {
GDCLASS(ExampleAbstract, Object);
protected:
static void _bind_methods() {}
};
#endif // EXAMPLE_CLASS_H
|
