godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #12093 from karroffel/gdnative-fixups 

fixes to GDNative and ARVRInterfaceGDNative
This commit is contained in:
Thomas Herzog 2017-10-14 19:29:55 +02:00 committed by GitHub
parent 9862dcd0cb e0019453a2
commit ad44b3d522
11 changed files with 208 additions and 643 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
modules/gdnative/gdnative.cpp
View File

@ -199,10 +199,7 @@ void GDNative::_bind_methods() {
ClassDB::bind_method(D_METHOD("initialize"), &GDNative::initialize);
ClassDB::bind_method(D_METHOD("terminate"), &GDNative::terminate);
// TODO(karroffel): get_native_(raw_)call_types binding?
// TODO(karroffel): make this a varargs function?
ClassDB::bind_method(D_METHOD("call_native", "procedure_name", "arguments"), &GDNative::call_native);
ClassDB::bind_method(D_METHOD("call_native", "calling_type", "procedure_name", "arguments"), &GDNative::call_native);
ADD_PROPERTYNZ(PropertyInfo(Variant::OBJECT, "library", PROPERTY_HINT_RESOURCE_TYPE, "GDNativeLibrary"), "set_library", "get_library");
}
@ -239,10 +236,7 @@ bool GDNative::initialize() {
}
void *library_init;
err = OS::get_singleton()->get_dynamic_library_symbol_handle(
native_handle,
init_symbol,
library_init);
err = get_symbol(init_symbol, library_init);
if (err || !library_init) {
OS::get_singleton()->close_dynamic_library(native_handle);
@ -277,11 +271,8 @@ bool GDNative::terminate() {
}
void *library_terminate;
Error error = OS::get_singleton()->get_dynamic_library_symbol_handle(
native_handle,
terminate_symbol,
library_terminate);
if (error) {
Error error = get_symbol(terminate_symbol, library_terminate);
if (error || !library_terminate) {
OS::get_singleton()->close_dynamic_library(native_handle);
native_handle = NULL;
return true;
@ -313,10 +304,6 @@ void GDNativeCallRegistry::register_native_call_type(StringName p_call_type, nat
native_calls.insert(p_call_type, p_callback);
}
void GDNativeCallRegistry::register_native_raw_call_type(StringName p_raw_call_type, native_raw_call_cb p_callback) {
native_raw_calls.insert(p_raw_call_type, p_callback);
}
Vector<StringName> GDNativeCallRegistry::get_native_call_types() {
Vector<StringName> call_types;
call_types.resize(native_calls.size());
@ -329,18 +316,6 @@ Vector<StringName> GDNativeCallRegistry::get_native_call_types() {
return call_types;
}
Vector<StringName> GDNativeCallRegistry::get_native_raw_call_types() {
Vector<StringName> call_types;
call_types.resize(native_raw_calls.size());
size_t idx = 0;
for (Map<StringName, native_raw_call_cb>::Element *E = native_raw_calls.front(); E; E = E->next(), idx++) {
call_types[idx] = E->key();
}
return call_types;
}
Variant GDNative::call_native(StringName p_native_call_type, StringName p_procedure_name, Array p_arguments) {
Map<StringName, native_call_cb>::Element *E = GDNativeCallRegistry::singleton->native_calls.find(p_native_call_type);
@ -349,20 +324,34 @@ Variant GDNative::call_native(StringName p_native_call_type, StringName p_proced
return Variant();
}
String procedure_name = p_procedure_name;
godot_variant result = E->get()(native_handle, (godot_string *)&procedure_name, (godot_array *)&p_arguments);
void *procedure_handle;
Error err = OS::get_singleton()->get_dynamic_library_symbol_handle(
native_handle,
p_procedure_name,
procedure_handle);
if (err != OK || procedure_handle == NULL) {
return Variant();
}
godot_variant result = E->get()(procedure_handle, (godot_array *)&p_arguments);
return *(Variant *)&result;
}
void GDNative::call_native_raw(StringName p_raw_call_type, StringName p_procedure_name, void *data, int num_args, void **args, void *r_return) {
Error GDNative::get_symbol(StringName p_procedure_name, void *&r_handle) {
Map<StringName, native_raw_call_cb>::Element *E = GDNativeCallRegistry::singleton->native_raw_calls.find(p_raw_call_type);
if (!E) {
ERR_PRINT((String("No handler for native raw call type \"" + p_raw_call_type) + "\" found").utf8().get_data());
return;
if (native_handle == NULL) {
ERR_PRINT("No valid library handle, can't get symbol from GDNative object");
return ERR_CANT_OPEN;
}
String procedure_name = p_procedure_name;
E->get()(native_handle, (godot_string *)&procedure_name, data, num_args, args, r_return);
Error result = OS::get_singleton()->get_dynamic_library_symbol_handle(
native_handle,
p_procedure_name,
r_handle,
true);
return result;
}

12
modules/gdnative/gdnative.h
View File

@ -100,8 +100,7 @@ public:
_FORCE_INLINE_ void set_singleton_gdnative(bool p_singleton) { singleton_gdnative = p_singleton; }
};
typedef godot_variant (*native_call_cb)(void *, godot_string *, godot_array *);
typedef void (*native_raw_call_cb)(void *, godot_string *, void *, int, void **, void *);
typedef godot_variant (*native_call_cb)(void *, godot_array *);
struct GDNativeCallRegistry {
static GDNativeCallRegistry *singleton;
@ -111,17 +110,13 @@ struct GDNativeCallRegistry {
}
inline GDNativeCallRegistry()
: native_calls(),
native_raw_calls() {}
: native_calls() {}
Map<StringName, native_call_cb> native_calls;
Map<StringName, native_raw_call_cb> native_raw_calls;
void register_native_call_type(StringName p_call_type, native_call_cb p_callback);
void register_native_raw_call_type(StringName p_raw_call_type, native_raw_call_cb p_callback);
Vector<StringName> get_native_call_types();
Vector<StringName> get_native_raw_call_types();
};
class GDNative : public Reference {
@ -149,7 +144,8 @@ public:
bool terminate();
Variant call_native(StringName p_native_call_type, StringName p_procedure_name, Array p_arguments = Array());
void call_native_raw(StringName p_raw_call_type, StringName p_procedure_name, void *data, int num_args, void **args, void *r_return);
Error get_symbol(StringName p_procedure_name, void *&r_handle);
};
#endif // GDNATIVE_H

8
modules/gdnative/gdnative_api.json
View File

@ -5230,6 +5230,14 @@
["godot_object *", "p_instance"]
]
},
{
"name": "godot_arvr_register_interface",
"return_type": "void",
"arguments": [
["const char *", "p_name"],
["const godot_arvr_interface_gdnative *", "p_interface"]
]
},
{
"name": "godot_arvr_get_worldscale",
"return_type": "godot_real",

4
modules/gdnative/include/gdnative/gdnative.h
View File

@ -47,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
@ -255,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

22
modules/gdnative/include/nativearvr/godot_nativearvr.h
View File

@ -36,6 +36,26 @@
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 char *p_name, 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();
@ -55,4 +75,4 @@ void GDAPI godot_arvr_set_controller_axis(godot_int p_controller_id, godot_int p
}
#endif
#endif /* !GODOT_NATIVEARVR_H */
#endif /* !GODOT_NATIVEARVR_H */

191
modules/gdnative/nativearvr/arvr_interface_gdnative.cpp
View File

@ -33,12 +33,18 @@
#include "servers/arvr/arvr_positional_tracker.h"
#include "servers/visual/visual_server_global.h"
#include "oa_hash_map.h"
extern OAHashMap<StringName, godot_arvr_interface_gdnative *> *_registered_interfaces;
ARVRInterfaceGDNative::ARVRInterfaceGDNative() {
// testing
printf("Construct gdnative interface\n");
// we won't have our data pointer until our library gets set
data = NULL;
interface = NULL;
}
ARVRInterfaceGDNative::~ARVRInterfaceGDNative() {
@ -53,38 +59,42 @@ ARVRInterfaceGDNative::~ARVRInterfaceGDNative() {
}
void ARVRInterfaceGDNative::cleanup() {
if (data != NULL) {
library->call_native_raw("arvr_call_destructor", "godot_arvr_destructor", data, 0, NULL, NULL);
if (interface != NULL) {
interface->destructor(data);
data = NULL;
};
interface = NULL;
}
}
if (library.is_valid()) {
library->terminate();
};
};
void ARVRInterfaceGDNative::set_interface(StringName p_name) {
void ARVRInterfaceGDNative::set_gdnative_library(Ref<GDNativeLibrary> p_library) {
if (library.is_null()) {
library.instance();
} else {
godot_arvr_interface_gdnative *new_interface;
if (!_registered_interfaces->lookup(p_name, &new_interface)) {
ERR_PRINT((String("ARVR interface \"") + p_name + "\" does not exist.").utf8().get_data());
return;
}
if (interface) {
cleanup();
};
}
library->set_library(p_library);
library->initialize();
interface = new_interface;
// Now we do our constructing...
void *parameters[1];
parameters[0] = (void *)this;
library->call_native_raw("arvr_call_constructor", "godot_arvr_constructor", NULL, 1, parameters, &data);
data = interface->constructor((godot_object *)this);
}
StringName ARVRInterfaceGDNative::get_name() const {
StringName name;
ERR_FAIL_COND_V(data == NULL, StringName());
ERR_FAIL_COND_V(interface == NULL, StringName());
const_cast<GDNative *>(library.ptr())->call_native_raw("arvr_return_string", "godot_arvr_get_name", data, 0, NULL, &name);
godot_string result = interface->get_name(data);
StringName name = *(String *)&result;
godot_string_destroy(&result);
return name;
}
@ -92,58 +102,56 @@ StringName ARVRInterfaceGDNative::get_name() const {
int ARVRInterfaceGDNative::get_capabilities() const {
int capabilities;
ERR_FAIL_COND_V(data == NULL, 0); // 0 = None
ERR_FAIL_COND_V(interface == NULL, 0); // 0 = None
const_cast<GDNative *>(library.ptr())->call_native_raw("arvr_return_int", "godot_arvr_get_capabilities", data, 0, NULL, &capabilities);
capabilities = interface->get_capabilities(data);
return capabilities;
};
}
bool ARVRInterfaceGDNative::get_anchor_detection_is_enabled() const {
bool enabled;
ERR_FAIL_COND_V(data == NULL, false);
ERR_FAIL_COND_V(interface == NULL, false);
const_cast<GDNative *>(library.ptr())->call_native_raw("arvr_return_bool", "godot_arvr_get_anchor_detection_is_enabled", data, 0, NULL, &enabled);
enabled = interface->get_anchor_detection_is_enabled(data);
return enabled;
};
}
void ARVRInterfaceGDNative::set_anchor_detection_is_enabled(bool p_enable) {
void *parameters[1];
ERR_FAIL_COND(data == NULL);
ERR_FAIL_COND(interface == NULL);
parameters[0] = (void *)&p_enable;
library->call_native_raw("arvr_set_bool", "godot_arvr_set_anchor_detection_is_enabled", data, 1, parameters, NULL);
};
interface->set_anchor_detection_is_enabled(data, p_enable);
}
bool ARVRInterfaceGDNative::is_stereo() {
bool stereo;
ERR_FAIL_COND_V(data == NULL, false);
ERR_FAIL_COND_V(interface == NULL, false);
library->call_native_raw("arvr_return_bool", "godot_arvr_is_stereo", data, 0, NULL, &stereo);
stereo = interface->is_stereo(data);
return stereo;
};
}
bool ARVRInterfaceGDNative::is_initialized() {
bool initialized;
ERR_FAIL_COND_V(data == NULL, false);
ERR_FAIL_COND_V(interface == NULL, false);
library->call_native_raw("arvr_return_bool", "godot_arvr_is_initialized", data, 0, NULL, &initialized);
initialized = interface->is_initialized(data);
return initialized;
};
}
bool ARVRInterfaceGDNative::initialize() {
bool initialized;
ERR_FAIL_COND_V(data == NULL, false);
ERR_FAIL_COND_V(interface == NULL, false);
library->call_native_raw("arvr_return_bool", "godot_arvr_initialize", data, 0, NULL, &initialized);
initialized = interface->initialize(data);
if (initialized) {
// if we successfully initialize our interface and we don't have a primary interface yet, this becomes our primary interface
@ -158,7 +166,7 @@ bool ARVRInterfaceGDNative::initialize() {
}
void ARVRInterfaceGDNative::uninitialize() {
ERR_FAIL_COND(data == NULL);
ERR_FAIL_COND(interface == NULL);
ARVRServer *arvr_server = ARVRServer::get_singleton();
if (arvr_server != NULL) {
@ -166,78 +174,76 @@ void ARVRInterfaceGDNative::uninitialize() {
arvr_server->clear_primary_interface_if(this);
}
library->call_native_raw("arvr_call_method", "godot_arvr_uninitialize", data, 0, NULL, NULL);
interface->uninitialize(data);
}
Size2 ARVRInterfaceGDNative::get_recommended_render_targetsize() {
Size2 size;
ERR_FAIL_COND_V(data == NULL, Size2());
ERR_FAIL_COND_V(interface == NULL, Size2());
library->call_native_raw("arvr_return_vector2", "godot_arvr_get_recommended_render_targetsize", data, 0, NULL, &size);
godot_vector2 result = interface->get_recommended_render_targetsize(data);
Vector2 *vec = (Vector2 *)&result;
return size;
return *vec;
}
Transform ARVRInterfaceGDNative::get_transform_for_eye(ARVRInterface::Eyes p_eye, const Transform &p_cam_transform) {
void *parameters[2];
Transform ret;
Transform *ret;
ERR_FAIL_COND_V(data == NULL, Transform());
ERR_FAIL_COND_V(interface == NULL, Transform());
parameters[0] = (void *)&p_eye;
parameters[1] = (void *)&p_cam_transform;
library->call_native_raw("arvr_return_transform_for_eye", "godot_arvr_get_transform_for_eye", data, 2, parameters, &ret);
godot_transform t = interface->get_transform_for_eye(data, (int)p_eye, (godot_transform *)&p_cam_transform);
return ret;
ret = (Transform *)&t;
return *ret;
}
CameraMatrix ARVRInterfaceGDNative::get_projection_for_eye(ARVRInterface::Eyes p_eye, real_t p_aspect, real_t p_z_near, real_t p_z_far) {
void *parameters[5];
CameraMatrix cm;
ERR_FAIL_COND_V(data == NULL, CameraMatrix());
ERR_FAIL_COND_V(interface == NULL, CameraMatrix());
parameters[0] = (void *)cm.matrix;
parameters[1] = (void *)&p_eye;
parameters[2] = (void *)&p_aspect;
parameters[3] = (void *)&p_z_near;
parameters[4] = (void *)&p_z_far;
library->call_native_raw("arvr_call_fill_projection_for_eye", "godot_arvr_fill_projection_for_eye", data, 5, parameters, NULL);
interface->fill_projection_for_eye(data, (godot_real *)cm.matrix, (godot_int)p_eye, p_aspect, p_z_near, p_z_far);
return cm;
}
void ARVRInterfaceGDNative::commit_for_eye(ARVRInterface::Eyes p_eye, RID p_render_target, const Rect2 &p_screen_rect) {
void *parameters[3];
ERR_FAIL_COND(data == NULL);
ERR_FAIL_COND(interface == NULL);
parameters[0] = (void *)&p_eye;
parameters[1] = (void *)&p_render_target;
parameters[2] = (void *)&p_screen_rect;
library->call_native_raw("arvr_call_commit_for_eye", "godot_arvr_commit_for_eye", data, 3, parameters, NULL);
interface->commit_for_eye(data, (godot_int)p_eye, (godot_rid *)&p_render_target, (godot_rect2 *)&p_screen_rect);
}
void ARVRInterfaceGDNative::process() {
ERR_FAIL_COND(data == NULL);
ERR_FAIL_COND(interface == NULL);
library->call_native_raw("arvr_call_method", "godot_arvr_process", data, 0, NULL, NULL);
interface->process(data);
}
void ARVRInterfaceGDNative::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_gdnative_library", "library"), &ARVRInterfaceGDNative::set_gdnative_library);
ClassDB::bind_method(D_METHOD("set_interface", "name"), &ARVRInterfaceGDNative::set_interface);
}
/////////////////////////////////////////////////////////////////////////////////////
// some helper callbacks
extern "C" {
void GDAPI godot_arvr_register_interface(const char *p_name, const godot_arvr_interface_gdnative *p_interface) {
// this method is supposed to only be called by GDNative singletons
// which are initialized in a thread safe way, so using a global map is fine here
_registered_interfaces->set(StringName(p_name), (godot_arvr_interface_gdnative * const)p_interface);
}
godot_real GDAPI godot_arvr_get_worldscale() {
ARVRServer *arvr_server = ARVRServer::get_singleton();
ERR_FAIL_NULL_V(arvr_server, 1.0);
return arvr_server->get_world_scale();
};
}
godot_transform GDAPI godot_arvr_get_reference_frame() {
godot_transform reference_frame;
@ -248,10 +254,10 @@ godot_transform GDAPI godot_arvr_get_reference_frame() {
*reference_frame_ptr = arvr_server->get_reference_frame();
} else {
godot_transform_new_identity(&reference_frame);
};
}
return reference_frame;
};
}
void GDAPI godot_arvr_blit(godot_int p_eye, godot_rid *p_render_target, godot_rect2 *p_rect) {
// blits out our texture as is, handy for preview display of one of the eyes that is already rendered with lens distortion on an external HMD
@ -268,7 +274,7 @@ void GDAPI godot_arvr_blit(godot_int p_eye, godot_rid *p_render_target, godot_re
VSG::rasterizer->set_current_render_target(RID());
VSG::rasterizer->blit_render_target_to_screen(*render_target, screen_rect, 0);
};
}
godot_int GDAPI godot_arvr_get_texid(godot_rid *p_render_target) {
// In order to send off our textures to display on our hardware we need the opengl texture ID instead of the render target RID
@ -279,7 +285,7 @@ godot_int GDAPI godot_arvr_get_texid(godot_rid *p_render_target) {
uint32_t texid = VS::get_singleton()->texture_get_texid(eye_texture);
return texid;
};
}
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) {
ARVRServer *arvr_server = ARVRServer::get_singleton();
@ -295,30 +301,30 @@ godot_int GDAPI godot_arvr_add_controller(char *p_device_name, godot_int p_hand,
new_tracker->set_hand(ARVRPositionalTracker::TRACKER_LEFT_HAND);
} else if (p_hand == 2) {
new_tracker->set_hand(ARVRPositionalTracker::TRACKER_RIGHT_HAND);
};
}
// also register as joystick...
int joyid = input->get_unused_joy_id();
if (joyid != -1) {
new_tracker->set_joy_id(joyid);
input->joy_connection_changed(joyid, true, p_device_name, "");
};
}
if (p_tracks_orientation) {
Basis orientation;
new_tracker->set_orientation(orientation);
};
}
if (p_tracks_position) {
Vector3 position;
new_tracker->set_position(position);
};
}
// add our tracker to our server and remember its pointer
arvr_server->add_tracker(new_tracker);
// note, this ID is only unique within controllers!
return new_tracker->get_tracker_id();
};
}
void GDAPI godot_arvr_remove_controller(godot_int p_controller_id) {
ARVRServer *arvr_server = ARVRServer::get_singleton();
@ -334,13 +340,13 @@ void GDAPI godot_arvr_remove_controller(godot_int p_controller_id) {
if (joyid != -1) {
input->joy_connection_changed(joyid, false, "", "");
remove_tracker->set_joy_id(-1);
};
}
// remove our tracker from our server
arvr_server->remove_tracker(remove_tracker);
memdelete(remove_tracker);
};
};
}
}
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) {
ARVRServer *arvr_server = ARVRServer::get_singleton();
@ -351,12 +357,12 @@ void GDAPI godot_arvr_set_controller_transform(godot_int p_controller_id, godot_
Transform *transform = (Transform *)p_transform;
if (p_tracks_orientation) {
tracker->set_orientation(transform->basis);
};
}
if (p_tracks_position) {
tracker->set_position(transform->origin);
};
};
};
}
}
}
void GDAPI godot_arvr_set_controller_button(godot_int p_controller_id, godot_int p_button, godot_bool p_is_pressed) {
ARVRServer *arvr_server = ARVRServer::get_singleton();
@ -370,9 +376,9 @@ void GDAPI godot_arvr_set_controller_button(godot_int p_controller_id, godot_int
int joyid = tracker->get_joy_id();
if (joyid != -1) {
input->joy_button(joyid, p_button, 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) {
ARVRServer *arvr_server = ARVRServer::get_singleton();
@ -389,6 +395,7 @@ void GDAPI godot_arvr_set_controller_axis(godot_int p_controller_id, godot_int p
jx.min = p_can_be_negative ? -1 : 0;
jx.value = p_value;
input->joy_axis(joyid, p_axis, jx);
};
};
};
}
}
}
}

6
modules/gdnative/nativearvr/arvr_interface_gdnative.h
View File

@ -41,12 +41,12 @@
*/
class ARVRInterfaceGDNative : public ARVRInterface {
GDCLASS(ARVRInterfaceGDNative, ARVRInterface);
GDCLASS(ARVRInterfaceGDNative, ARVRInterface)
void cleanup();
protected:
Ref<GDNative> library;
godot_arvr_interface_gdnative *interface;
void *data;
static void _bind_methods();
@ -56,7 +56,7 @@ public:
ARVRInterfaceGDNative();
~ARVRInterfaceGDNative();
void set_gdnative_library(Ref<GDNativeLibrary> p_library);
void set_interface(StringName p_name);
virtual StringName get_name() const;
virtual int get_capabilities() const;

381
modules/gdnative/nativearvr/register_types.cpp
View File

@ -33,382 +33,25 @@
#include "arvr_interface_gdnative.h"
#include "core/os/os.h"
void arvr_call_constructor(
void *p_handle,
godot_string *p_proc_name,
void *p_data,
int p_num_args,
void **p_args,
void *r_return) {
if (p_handle == NULL) {
ERR_PRINT("No valid library handle, can't call standard varcall procedure");
return;
}
#include "oa_hash_map.h"
#include "ustring.h"
void *library_proc;
Error err = OS::get_singleton()->get_dynamic_library_symbol_handle(
p_handle,
*(String *)p_proc_name,
library_proc,
true); // we roll our own message
if (err != OK) {
ERR_PRINT((String("GDNative procedure \"" + *(String *)p_proc_name) + "\" does not exists and can't be called").utf8().get_data());
return;
}
// what is this?? I can't memnew(OAHashMap<String, godot_arvr_interface_gdnative *>)
// but with this typedef it's working just fine...
// C++ grammar can be a joy.
typedef OAHashMap<StringName, godot_arvr_interface_gdnative *> InterfaceMap;
void *(*proc)(godot_object *);
proc = (void *(*)(godot_object *))library_proc;
godot_object *this_object = (godot_object *)p_args[0];
void *p = proc(this_object);
void **return_ptr = (void **)r_return;
*return_ptr = p;
};
void arvr_call_destructor(
void *p_handle,
godot_string *p_proc_name,
void *p_data,
int p_num_args,
void **p_args,
void *r_return) {
if (p_handle == NULL) {
ERR_PRINT("No valid library handle, can't call standard varcall procedure");
return;
}
void *library_proc;
Error err = OS::get_singleton()->get_dynamic_library_symbol_handle(
p_handle,
*(String *)p_proc_name,
library_proc,
true); // we roll our own message
if (err != OK) {
ERR_PRINT((String("GDNative procedure \"" + *(String *)p_proc_name) + "\" does not exists and can't be called").utf8().get_data());
return;
}
void (*proc)(void *);
proc = (void (*)(void *))library_proc;
proc(p_data);
};
void arvr_return_string(
void *p_handle,
godot_string *p_proc_name,
void *p_data,
int p_num_args,
void **p_args,
void *r_return) {
if (p_handle == NULL) {
ERR_PRINT("No valid library handle, can't call standard varcall procedure");
return;
}
void *library_proc;
Error err = OS::get_singleton()->get_dynamic_library_symbol_handle(
p_handle,
*(String *)p_proc_name,
library_proc,
true); // we roll our own message
if (err != OK) {
ERR_PRINT((String("GDNative procedure \"" + *(String *)p_proc_name) + "\" does not exists and can't be called").utf8().get_data());
return;
}
godot_string (*proc)(void *);
proc = (godot_string(*)(void *))library_proc;
godot_string s = proc(p_data);
StringName *return_ptr = (StringName *)r_return;
String *returned_string = (String *)&s;
*return_ptr = *returned_string;
godot_string_destroy(&s);
};
void arvr_return_int(
void *p_handle,
godot_string *p_proc_name,
void *p_data,
int p_num_args,
void **p_args,
void *r_return) {
if (p_handle == NULL) {
ERR_PRINT("No valid library handle, can't call standard varcall procedure");
return;
}
void *library_proc;
Error err = OS::get_singleton()->get_dynamic_library_symbol_handle(
p_handle,
*(String *)p_proc_name,
library_proc,
true); // we roll our own message
if (err != OK) {
ERR_PRINT((String("GDNative procedure \"" + *(String *)p_proc_name) + "\" does not exists and can't be called").utf8().get_data());
return;
}
godot_int (*proc)(void *);
proc = (godot_int(*)(void *))library_proc;
godot_int i = proc(p_data);
int *return_ptr = (int *)r_return;
*return_ptr = i;
};
void arvr_return_bool(
void *p_handle,
godot_string *p_proc_name,
void *p_data,
int p_num_args,
void **p_args,
void *r_return) {
if (p_handle == NULL) {
ERR_PRINT("No valid library handle, can't call standard varcall procedure");
return;
}
void *library_proc;
Error err = OS::get_singleton()->get_dynamic_library_symbol_handle(
p_handle,
*(String *)p_proc_name,
library_proc,
true); // we roll our own message
if (err != OK) {
ERR_PRINT((String("GDNative procedure \"" + *(String *)p_proc_name) + "\" does not exists and can't be called").utf8().get_data());
return;
}
godot_bool (*proc)(void *);
proc = (godot_bool(*)(void *))library_proc;
godot_bool b = proc(p_data);
int *return_ptr = (int *)r_return;
*return_ptr = b;
};
void arvr_set_bool(
void *p_handle,
godot_string *p_proc_name,
void *p_data,
int p_num_args,
void **p_args,
void *r_return) {
if (p_handle == NULL) {
ERR_PRINT("No valid library handle, can't call standard varcall procedure");
return;
}
void *library_proc;
Error err = OS::get_singleton()->get_dynamic_library_symbol_handle(
p_handle,
*(String *)p_proc_name,
library_proc,
true); // we roll our own message
if (err != OK) {
ERR_PRINT((String("GDNative procedure \"" + *(String *)p_proc_name) + "\" does not exists and can't be called").utf8().get_data());
return;
}
void (*proc)(void *, bool);
proc = (void (*)(void *, bool))library_proc;
bool *set_bool = (bool *)p_args[0];
proc(p_data, *set_bool);
};
void arvr_call_method(
void *p_handle,
godot_string *p_proc_name,
void *p_data,
int p_num_args,
void **p_args,
void *r_return) {
if (p_handle == NULL) {
ERR_PRINT("No valid library handle, can't call standard varcall procedure");
return;
}
void *library_proc;
Error err = OS::get_singleton()->get_dynamic_library_symbol_handle(
p_handle,
*(String *)p_proc_name,
library_proc,
true); // we roll our own message
if (err != OK) {
ERR_PRINT((String("GDNative procedure \"" + *(String *)p_proc_name) + "\" does not exists and can't be called").utf8().get_data());
return;
}
godot_bool (*proc)(void *);
proc = (godot_bool(*)(void *))library_proc;
proc(p_data);
};
void arvr_return_vector2(
void *p_handle,
godot_string *p_proc_name,
void *p_data,
int p_num_args,
void **p_args,
void *r_return) {
if (p_handle == NULL) {
ERR_PRINT("No valid library handle, can't call standard varcall procedure");
return;
}
void *library_proc;
Error err = OS::get_singleton()->get_dynamic_library_symbol_handle(
p_handle,
*(String *)p_proc_name,
library_proc,
true); // we roll our own message
if (err != OK) {
ERR_PRINT((String("GDNative procedure \"" + *(String *)p_proc_name) + "\" does not exists and can't be called").utf8().get_data());
return;
}
godot_vector2 (*proc)(void *);
proc = (godot_vector2(*)(void *))library_proc;
godot_vector2 v = proc(p_data);
godot_vector2 *return_ptr = (godot_vector2 *)r_return;
*return_ptr = v;
};
void arvr_return_transform_for_eye(
void *p_handle,
godot_string *p_proc_name,
void *p_data,
int p_num_args,
void **p_args,
void *r_return) {
if (p_handle == NULL) {
ERR_PRINT("No valid library handle, can't call standard varcall procedure");
return;
}
void *library_proc;
Error err = OS::get_singleton()->get_dynamic_library_symbol_handle(
p_handle,
*(String *)p_proc_name,
library_proc,
true); // we roll our own message
if (err != OK) {
ERR_PRINT((String("GDNative procedure \"" + *(String *)p_proc_name) + "\" does not exists and can't be called").utf8().get_data());
return;
}
godot_transform (*proc)(void *, int, godot_transform *);
proc = (godot_transform(*)(void *, int, godot_transform *))library_proc;
int *eye = (int *)p_args[0];
godot_transform *camera_transform = (godot_transform *)p_args[1];
godot_transform t = proc(p_data, *eye, camera_transform);
godot_transform *return_ptr = (godot_transform *)r_return;
*return_ptr = t;
};
void arvr_call_fill_projection_for_eye(
void *p_handle,
godot_string *p_proc_name,
void *p_data,
int p_num_args,
void **p_args,
void *r_return) {
if (p_handle == NULL) {
ERR_PRINT("No valid library handle, can't call standard varcall procedure");
return;
}
void *library_proc;
Error err = OS::get_singleton()->get_dynamic_library_symbol_handle(
p_handle,
*(String *)p_proc_name,
library_proc,
true); // we roll our own message
if (err != OK) {
ERR_PRINT((String("GDNative procedure \"" + *(String *)p_proc_name) + "\" does not exists and can't be called").utf8().get_data());
return;
}
void (*proc)(void *, real_t *, int, real_t, real_t, real_t);
proc = (void (*)(void *, real_t *, int, real_t, real_t, real_t))library_proc;
real_t *projection = (real_t *)p_args[0]; // <-- we'll be writing into this buffer, must have enough space for 16 floats!
int *eye = (int *)p_args[1];
real_t *aspect = (real_t *)p_args[2];
real_t *zn = (real_t *)p_args[3];
real_t *zf = (real_t *)p_args[4];
proc(p_data, projection, *eye, *aspect, *zn, *zf);
};
void arvr_call_commit_for_eye(
void *p_handle,
godot_string *p_proc_name,
void *p_data,
int p_num_args,
void **p_args,
void *r_return) {
if (p_handle == NULL) {
ERR_PRINT("No valid library handle, can't call standard varcall procedure");
return;
}
void *library_proc;
Error err = OS::get_singleton()->get_dynamic_library_symbol_handle(
p_handle,
*(String *)p_proc_name,
library_proc,
true); // we roll our own message
if (err != OK) {
ERR_PRINT((String("GDNative procedure \"" + *(String *)p_proc_name) + "\" does not exists and can't be called").utf8().get_data());
return;
}
void (*proc)(void *, int, godot_rid *, godot_rect2 *);
proc = (void (*)(void *, int, godot_rid *, godot_rect2 *))library_proc;
int *eye = (int *)p_args[0];
godot_rid *rid = (godot_rid *)p_args[1];
godot_rect2 *screen_rect = (godot_rect2 *)p_args[2];
proc(p_data, *eye, rid, screen_rect);
};
InterfaceMap *_registered_interfaces;
void register_nativearvr_types() {
GDNativeCallRegistry::singleton->register_native_raw_call_type("arvr_call_constructor", arvr_call_constructor);
GDNativeCallRegistry::singleton->register_native_raw_call_type("arvr_call_destructor", arvr_call_destructor);
GDNativeCallRegistry::singleton->register_native_raw_call_type("arvr_return_string", arvr_return_string);
GDNativeCallRegistry::singleton->register_native_raw_call_type("arvr_return_int", arvr_return_int);
GDNativeCallRegistry::singleton->register_native_raw_call_type("arvr_return_bool", arvr_return_bool);
GDNativeCallRegistry::singleton->register_native_raw_call_type("arvr_set_bool", arvr_set_bool);
GDNativeCallRegistry::singleton->register_native_raw_call_type("arvr_call_method", arvr_call_method);
GDNativeCallRegistry::singleton->register_native_raw_call_type("arvr_return_vector2", arvr_return_vector2);
GDNativeCallRegistry::singleton->register_native_raw_call_type("arvr_return_transform_for_eye", arvr_return_transform_for_eye);
GDNativeCallRegistry::singleton->register_native_raw_call_type("arvr_call_fill_projection_for_eye", arvr_call_fill_projection_for_eye);
GDNativeCallRegistry::singleton->register_native_raw_call_type("arvr_call_commit_for_eye", arvr_call_commit_for_eye);
_registered_interfaces = memnew(InterfaceMap);
ClassDB::register_class<ARVRInterfaceGDNative>();
}
void unregister_nativearvr_types() {
memdelete(_registered_interfaces);
_registered_interfaces = NULL;
}

42
modules/gdnative/nativescript/nativescript.cpp
View File

@ -1010,17 +1010,12 @@ void NativeScriptLanguage::init_library(const Ref<GDNativeLibrary> &lib) {
if (!library_script_users.has(lib_path))
library_script_users.insert(lib_path, Set<NativeScript *>());
void *args[1] = {
(void *)&lib_path
};
void *proc_ptr;
gdn->get_symbol(_init_call_name, proc_ptr);
((void (*)(godot_string *))proc_ptr)((godot_string *)&lib_path);
// here the library registers all the classes and stuff.
gdn->call_native_raw(_init_call_type,
_init_call_name,
NULL,
1,
args,
NULL);
} else {
// already initialized. Nice.
}
@ -1053,13 +1048,15 @@ void NativeScriptLanguage::call_libraries_cb(const StringName &name) {
// library_gdnatives is modified only from the main thread, so it's safe not to use mutex here
for (Map<String, Ref<GDNative> >::Element *L = library_gdnatives.front(); L; L = L->next()) {
if (L->get()->is_initialized()) {
L->get()->call_native_raw(
_noarg_call_type,
name,
NULL,
0,
NULL,
NULL);
void *proc_ptr;
Error err = L->get()->get_symbol(name, proc_ptr);
if (err != OK) {
ERR_PRINT((String("No godot_gdnative_init in \"" + L->get()->get_library()->get_active_library_path()) + "\" found").utf8().get_data());
} else {
((void (*)())proc_ptr)();
}
}
}
}
@ -1142,12 +1139,11 @@ void NativeReloadNode::_notification(int p_what) {
};
// here the library registers all the classes and stuff.
L->get()->call_native_raw(NSL->_init_call_type,
NSL->_init_call_name,
NULL,
1,
args,
NULL);
void *proc_ptr;
L->get()->get_symbol("godot_nativescript_init", proc_ptr);
((void (*)(void *))proc_ptr)((void *)&L->key());
for (Map<String, Set<NativeScript *> >::Element *U = NSL->library_script_users.front(); U; U = U->next()) {
for (Set<NativeScript *>::Element *S = U->get().front(); S; S = S->next()) {

50
modules/gdnative/nativescript/register_types.cpp
View File

@ -38,53 +38,6 @@
NativeScriptLanguage *native_script_language;
typedef void (*native_script_init_fn)(void *);
void init_call_cb(void *p_handle, godot_string *p_proc_name, void *p_data, int p_num_args, void **args, void *r_ret) {
if (p_handle == NULL) {
ERR_PRINT("No valid library handle, can't call nativescript init procedure");
return;
}
void *library_proc;
Error err = OS::get_singleton()->get_dynamic_library_symbol_handle(
p_handle,
*(String *)p_proc_name,
library_proc,
true); // we print our own message
if (err != OK) {
ERR_PRINT((String("GDNative procedure \"" + *(String *)p_proc_name) + "\" does not exists and can't be called").utf8().get_data());
return;
}
native_script_init_fn fn = (native_script_init_fn)library_proc;
fn(args[0]);
}
typedef void (*native_script_empty_callback)();
void noarg_call_cb(void *p_handle, godot_string *p_proc_name, void *p_data, int p_num_args, void **args, void *r_ret) {
if (p_handle == NULL) {
ERR_PRINT("No valid library handle, can't call nativescript callback");
return;
}
void *library_proc;
Error err = OS::get_singleton()->get_dynamic_library_symbol_handle(
p_handle,
*(String *)p_proc_name,
library_proc,
true);
if (err != OK) {
// it's fine if thread callbacks are not present in the library.
return;
}
native_script_empty_callback fn = (native_script_empty_callback)library_proc;
fn();
}
ResourceFormatLoaderNativeScript *resource_loader_gdns = NULL;
ResourceFormatSaverNativeScript *resource_saver_gdns = NULL;
@ -95,9 +48,6 @@ void register_nativescript_types() {
ScriptServer::register_language(native_script_language);
GDNativeCallRegistry::singleton->register_native_raw_call_type(native_script_language->_init_call_type, init_call_cb);
GDNativeCallRegistry::singleton->register_native_raw_call_type(native_script_language->_noarg_call_type, noarg_call_cb);
resource_saver_gdns = memnew(ResourceFormatSaverNativeScript);
ResourceSaver::add_resource_format_saver(resource_saver_gdns);

70
modules/gdnative/register_types.cpp
View File

@ -128,57 +128,12 @@ static void editor_init_callback() {
#endif
godot_variant cb_standard_varcall(void *handle, godot_string *p_procedure, godot_array *p_args) {
if (handle == NULL) {
ERR_PRINT("No valid library handle, can't call standard varcall procedure");
godot_variant ret;
godot_variant_new_nil(&ret);
return ret;
}
void *library_proc;
Error err = OS::get_singleton()->get_dynamic_library_symbol_handle(
handle,
*(String *)p_procedure,
library_proc,
true); // we roll our own message
if (err != OK) {
ERR_PRINT((String("GDNative procedure \"" + *(String *)p_procedure) + "\" does not exists and can't be called").utf8().get_data());
godot_variant ret;
godot_variant_new_nil(&ret);
return ret;
}
godot_variant cb_standard_varcall(void *p_procedure_handle, godot_array *p_args) {
godot_gdnative_procedure_fn proc;
proc = (godot_gdnative_procedure_fn)library_proc;
proc = (godot_gdnative_procedure_fn)p_procedure_handle;
return proc(NULL, p_args);
}
void cb_singleton_call(
void *p_handle,
godot_string *p_proc_name,
void *p_data,
int p_num_args,
void **p_args,
void *r_return) {
if (p_handle == NULL) {
ERR_PRINT("No valid library handle, can't call singleton procedure");
return;
}
void *singleton_proc;
Error err = OS::get_singleton()->get_dynamic_library_symbol_handle(
p_handle,
*(String *)p_proc_name,
singleton_proc);
if (err != OK) {
return;
}
void (*singleton_procedure_ptr)() = (void (*)())singleton_proc;
singleton_procedure_ptr();
return proc(p_args);
}
GDNativeCallRegistry *GDNativeCallRegistry::singleton;
@ -201,8 +156,6 @@ void register_gdnative_types() {
GDNativeCallRegistry::singleton->register_native_call_type("standard_varcall", cb_standard_varcall);
GDNativeCallRegistry::singleton->register_native_raw_call_type("gdnative_singleton_call", cb_singleton_call);
register_nativearvr_types();
register_nativescript_types();
@ -225,13 +178,16 @@ void register_gdnative_types() {
continue;
}
singleton_gdnatives[i]->call_native_raw(
"gdnative_singleton_call",
void *proc_ptr;
Error err = singleton_gdnatives[i]->get_symbol(
"godot_gdnative_singleton",
NULL,
0,
NULL,
NULL);
proc_ptr);
if (err != OK) {
ERR_PRINT((String("No godot_gdnative_singleton in \"" + singleton_gdnatives[i]->get_library()->get_active_library_path()) + "\" found").utf8().get_data());
} else {
((void (*)())proc_ptr)();
}
}
}
@ -283,4 +239,4 @@ void unregister_gdnative_types() {
print_line(String("vector2:\t") + itos(sizeof(Vector2)));
print_line(String("vector3:\t") + itos(sizeof(Vector3)));
*/
}
}