generated.c

extern const godot_gdnative_core_api_struct *api;
VALUE rb_godot_bool_from_godot (godot_bool);
godot_bool rb_godot_bool_to_godot (VALUE);
VALUE rb_godot_real_from_godot (godot_real);
godot_real rb_godot_real_to_godot (VALUE);
VALUE rb_godot_int_from_godot (godot_int);
godot_int rb_godot_int_to_godot (VALUE);
VALUE rb_godot_vector3_axis_from_godot (godot_vector3_axis);
godot_vector3_axis rb_godot_vector3_axis_to_godot (VALUE);
VALUE rb_signed_char_from_godot (signed char);
signed char rb_signed_char_to_godot (VALUE);
VALUE rb_uint32_t_from_godot (uint32_t);
uint32_t rb_uint32_t_to_godot (VALUE);
VALUE rb_godot_error_from_godot (godot_error);
godot_error rb_godot_error_to_godot (VALUE);
VALUE rb_godot_aabb_from_godot (godot_aabb);
godot_aabb rb_godot_aabb_to_godot (VALUE);
VALUE rb_godot_aabb_pointer_from_godot (godot_aabb *);
godot_aabb * rb_godot_aabb_pointer_to_godot (VALUE);
VALUE rb_godot_basis_from_godot (godot_basis);
godot_basis rb_godot_basis_to_godot (VALUE);
VALUE rb_godot_basis_pointer_from_godot (godot_basis *);
godot_basis * rb_godot_basis_pointer_to_godot (VALUE);
VALUE rb_godot_color_from_godot (godot_color);
godot_color rb_godot_color_to_godot (VALUE);
VALUE rb_godot_color_pointer_from_godot (godot_color *);
godot_color * rb_godot_color_pointer_to_godot (VALUE);
VALUE rb_godot_plane_from_godot (godot_plane);
godot_plane rb_godot_plane_to_godot (VALUE);
VALUE rb_godot_plane_pointer_from_godot (godot_plane *);
godot_plane * rb_godot_plane_pointer_to_godot (VALUE);
VALUE rb_godot_quat_from_godot (godot_quat);
godot_quat rb_godot_quat_to_godot (VALUE);
VALUE rb_godot_quat_pointer_from_godot (godot_quat *);
godot_quat * rb_godot_quat_pointer_to_godot (VALUE);
VALUE rb_godot_rect2_from_godot (godot_rect2);
godot_rect2 rb_godot_rect2_to_godot (VALUE);
VALUE rb_godot_rect2_pointer_from_godot (godot_rect2 *);
godot_rect2 * rb_godot_rect2_pointer_to_godot (VALUE);
VALUE rb_godot_string_from_godot (godot_string);
godot_string rb_godot_string_to_godot (VALUE);
VALUE rb_godot_string_pointer_from_godot (godot_string *);
godot_string * rb_godot_string_pointer_to_godot (VALUE);
VALUE rb_godot_transform_from_godot (godot_transform);
godot_transform rb_godot_transform_to_godot (VALUE);
VALUE rb_godot_transform_pointer_from_godot (godot_transform *);
godot_transform * rb_godot_transform_pointer_to_godot (VALUE);
VALUE rb_godot_transform2d_from_godot (godot_transform2d);
godot_transform2d rb_godot_transform2d_to_godot (VALUE);
VALUE rb_godot_transform2d_pointer_from_godot (godot_transform2d *);
godot_transform2d * rb_godot_transform2d_pointer_to_godot (VALUE);
VALUE rb_godot_vector2_from_godot (godot_vector2);
godot_vector2 rb_godot_vector2_to_godot (VALUE);
VALUE rb_godot_vector2_pointer_from_godot (godot_vector2 *);
godot_vector2 * rb_godot_vector2_pointer_to_godot (VALUE);
VALUE rb_godot_vector3_from_godot (godot_vector3);
godot_vector3 rb_godot_vector3_to_godot (VALUE);
VALUE rb_godot_vector3_pointer_from_godot (godot_vector3 *);
godot_vector3 * rb_godot_vector3_pointer_to_godot (VALUE);
VALUE rb_godot_node_path_from_godot (godot_node_path);
godot_node_path rb_godot_node_path_to_godot (VALUE);
VALUE rb_godot_node_path_pointer_from_godot (godot_node_path *);
godot_node_path * rb_godot_node_path_pointer_to_godot (VALUE);
VALUE rb_godot_array_from_godot (godot_array);
godot_array rb_godot_array_to_godot (VALUE);
VALUE rb_godot_array_pointer_from_godot (godot_array *);
godot_array * rb_godot_array_pointer_to_godot (VALUE);
VALUE rb_godot_dictionary_from_godot (godot_dictionary);
godot_dictionary rb_godot_dictionary_to_godot (VALUE);
VALUE rb_godot_dictionary_pointer_from_godot (godot_dictionary *);
godot_dictionary * rb_godot_dictionary_pointer_to_godot (VALUE);
VALUE rb_godot_object_pointer_from_godot (godot_object *);
godot_object * rb_godot_object_pointer_to_godot (VALUE);
VALUE rb_godot_pool_string_array_from_godot (godot_pool_string_array);
godot_pool_string_array rb_godot_pool_string_array_to_godot (VALUE);
VALUE rb_godot_pool_string_array_pointer_from_godot (godot_pool_string_array *);
godot_pool_string_array * rb_godot_pool_string_array_pointer_to_godot (VALUE);
VALUE rb_godot_variant_from_godot (godot_variant);
godot_variant rb_godot_variant_to_godot (VALUE);
VALUE rb_godot_variant_pointer_from_godot (godot_variant *);
VALUE rb_wchar_t_pointer_from_godot (wchar_t *);
wchar_t * rb_wchar_t_pointer_to_godot (VALUE);
VALUE rb_wchar_t_from_godot (wchar_t);
wchar_t rb_wchar_t_to_godot (VALUE);static VALUE Aabb_class;
static VALUE Basis_class;
static VALUE Color_class;
static VALUE Plane_class;
static VALUE Quat_class;
static VALUE Rect2_class;
static VALUE Transform_class;
static VALUE Transform2D_class;
static VALUE Vector2_class;
static VALUE Vector3_class;
static VALUE Array_class;
static VALUE Dictionary_class;
static VALUE NodePath_class;
static VALUE Object_class;
static VALUE PoolStringArray_class;
static VALUE String_class;
VALUE rb_godot_bool_from_godot (godot_bool addr) {
  return (addr ? Qtrue: Qfalse);
}
godot_bool rb_godot_bool_to_godot (VALUE self) {
  return (RTEST(self) ? GODOT_TRUE : GODOT_FALSE);
}
VALUE rb_godot_real_from_godot (godot_real addr) {
  return DBL2NUM(addr);
}
godot_real rb_godot_real_to_godot (VALUE self) {
  return NUM2DBL(self);
}
VALUE rb_godot_int_from_godot (godot_int addr) {
  return LONG2NUM(addr);
}
godot_int rb_godot_int_to_godot (VALUE self) {
  return NUM2LONG(self);
}
VALUE rb_godot_vector3_axis_from_godot (godot_vector3_axis addr) {
  return LONG2NUM(addr);
}
godot_vector3_axis rb_godot_vector3_axis_to_godot (VALUE self) {
  return NUM2LONG(self);
}
VALUE rb_signed_char_from_godot (signed char addr) {
  return LONG2NUM(addr);
}
signed char rb_signed_char_to_godot (VALUE self) {
  return NUM2LONG(self);
}
VALUE rb_uint32_t_from_godot (uint32_t addr) {
  return LONG2NUM(addr);
}
uint32_t rb_uint32_t_to_godot (VALUE self) {
  return NUM2LONG(self);
}
VALUE rb_godot_error_from_godot (godot_error addr) {
  return LONG2NUM(addr);
}
godot_error rb_godot_error_to_godot (VALUE self) {
  return NUM2LONG(self);
}
VALUE rb_godot_aabb_from_godot (godot_aabb addr) {
  return rb_godot_aabb_pointer_from_godot(&addr);
}
godot_aabb rb_godot_aabb_to_godot (VALUE self) {
  return *rb_godot_aabb_pointer_to_godot(self);
}
VALUE rb_godot_aabb_pointer_from_godot (godot_aabb * addr) {
  godot_aabb * naddr = api->godot_alloc(sizeof(godot_aabb ));
  memcpy(naddr, addr, sizeof(godot_aabb ));
  VALUE obj = rb_funcall(Aabb_class, rb_intern("_adopt"), 1, LONG2NUM((long)naddr));
  return obj;
}
godot_aabb * rb_godot_aabb_pointer_to_godot (VALUE self) {
  VALUE addr = rb_iv_get(self, "@_godot_address");
  return (godot_aabb *)NUM2LONG(addr);
}
VALUE rb_godot_basis_from_godot (godot_basis addr) {
  return rb_godot_basis_pointer_from_godot(&addr);
}
godot_basis rb_godot_basis_to_godot (VALUE self) {
  return *rb_godot_basis_pointer_to_godot(self);
}
VALUE rb_godot_basis_pointer_from_godot (godot_basis * addr) {
  godot_basis * naddr = api->godot_alloc(sizeof(godot_basis ));
  memcpy(naddr, addr, sizeof(godot_basis ));
  VALUE obj = rb_funcall(Basis_class, rb_intern("_adopt"), 1, LONG2NUM((long)naddr));
  return obj;
}
godot_basis * rb_godot_basis_pointer_to_godot (VALUE self) {
  VALUE addr = rb_iv_get(self, "@_godot_address");
  return (godot_basis *)NUM2LONG(addr);
}
VALUE rb_godot_color_from_godot (godot_color addr) {
  return rb_godot_color_pointer_from_godot(&addr);
}
godot_color rb_godot_color_to_godot (VALUE self) {
  return *rb_godot_color_pointer_to_godot(self);
}
VALUE rb_godot_color_pointer_from_godot (godot_color * addr) {
  godot_color * naddr = api->godot_alloc(sizeof(godot_color ));
  memcpy(naddr, addr, sizeof(godot_color ));
  VALUE obj = rb_funcall(Color_class, rb_intern("_adopt"), 1, LONG2NUM((long)naddr));
  return obj;
}
godot_color * rb_godot_color_pointer_to_godot (VALUE self) {
  VALUE addr = rb_iv_get(self, "@_godot_address");
  return (godot_color *)NUM2LONG(addr);
}
VALUE rb_godot_plane_from_godot (godot_plane addr) {
  return rb_godot_plane_pointer_from_godot(&addr);
}
godot_plane rb_godot_plane_to_godot (VALUE self) {
  return *rb_godot_plane_pointer_to_godot(self);
}
VALUE rb_godot_plane_pointer_from_godot (godot_plane * addr) {
  godot_plane * naddr = api->godot_alloc(sizeof(godot_plane ));
  memcpy(naddr, addr, sizeof(godot_plane ));
  VALUE obj = rb_funcall(Plane_class, rb_intern("_adopt"), 1, LONG2NUM((long)naddr));
  return obj;
}
godot_plane * rb_godot_plane_pointer_to_godot (VALUE self) {
  VALUE addr = rb_iv_get(self, "@_godot_address");
  return (godot_plane *)NUM2LONG(addr);
}
VALUE rb_godot_quat_from_godot (godot_quat addr) {
  return rb_godot_quat_pointer_from_godot(&addr);
}
godot_quat rb_godot_quat_to_godot (VALUE self) {
  return *rb_godot_quat_pointer_to_godot(self);
}
VALUE rb_godot_quat_pointer_from_godot (godot_quat * addr) {
  godot_quat * naddr = api->godot_alloc(sizeof(godot_quat ));
  memcpy(naddr, addr, sizeof(godot_quat ));
  VALUE obj = rb_funcall(Quat_class, rb_intern("_adopt"), 1, LONG2NUM((long)naddr));
  return obj;
}
godot_quat * rb_godot_quat_pointer_to_godot (VALUE self) {
  VALUE addr = rb_iv_get(self, "@_godot_address");
  return (godot_quat *)NUM2LONG(addr);
}
VALUE rb_godot_rect2_from_godot (godot_rect2 addr) {
  return rb_godot_rect2_pointer_from_godot(&addr);
}
godot_rect2 rb_godot_rect2_to_godot (VALUE self) {
  return *rb_godot_rect2_pointer_to_godot(self);
}
VALUE rb_godot_rect2_pointer_from_godot (godot_rect2 * addr) {
  godot_rect2 * naddr = api->godot_alloc(sizeof(godot_rect2 ));
  memcpy(naddr, addr, sizeof(godot_rect2 ));
  VALUE obj = rb_funcall(Rect2_class, rb_intern("_adopt"), 1, LONG2NUM((long)naddr));
  return obj;
}
godot_rect2 * rb_godot_rect2_pointer_to_godot (VALUE self) {
  VALUE addr = rb_iv_get(self, "@_godot_address");
  return (godot_rect2 *)NUM2LONG(addr);
}
VALUE rb_godot_string_from_godot (godot_string addr) {
  return rb_godot_string_pointer_from_godot(&addr);
}
godot_string rb_godot_string_to_godot (VALUE self) {
  return *rb_godot_string_pointer_to_godot(self);
}
VALUE rb_godot_string_pointer_from_godot (godot_string * addr) {
  godot_string * naddr = api->godot_alloc(sizeof(godot_string ));
  memcpy(naddr, addr, sizeof(godot_string ));
  // will copy increase the reference count?
  // api->godot_string_new_copy(naddr, addr);
  VALUE obj = rb_funcall(String_class, rb_intern("_adopt"), 1, LONG2NUM((long)naddr));
  return obj;
}
godot_string * rb_godot_string_pointer_to_godot (VALUE self) {
  VALUE addr = rb_iv_get(self, "@_godot_address");
  return (godot_string *)NUM2LONG(addr);
}
VALUE rb_godot_transform_from_godot (godot_transform addr) {
  return rb_godot_transform_pointer_from_godot(&addr);
}
godot_transform rb_godot_transform_to_godot (VALUE self) {
  return *rb_godot_transform_pointer_to_godot(self);
}
VALUE rb_godot_transform_pointer_from_godot (godot_transform * addr) {
  godot_transform * naddr = api->godot_alloc(sizeof(godot_transform ));
  memcpy(naddr, addr, sizeof(godot_transform ));
  VALUE obj = rb_funcall(Transform_class, rb_intern("_adopt"), 1, LONG2NUM((long)naddr));
  return obj;
}
godot_transform * rb_godot_transform_pointer_to_godot (VALUE self) {
  VALUE addr = rb_iv_get(self, "@_godot_address");
  return (godot_transform *)NUM2LONG(addr);
}
VALUE rb_godot_transform2d_from_godot (godot_transform2d addr) {
  return rb_godot_transform2d_pointer_from_godot(&addr);
}
godot_transform2d rb_godot_transform2d_to_godot (VALUE self) {
  return *rb_godot_transform2d_pointer_to_godot(self);
}
VALUE rb_godot_transform2d_pointer_from_godot (godot_transform2d * addr) {
  godot_transform2d * naddr = api->godot_alloc(sizeof(godot_transform2d ));
  memcpy(naddr, addr, sizeof(godot_transform2d ));
  VALUE obj = rb_funcall(Transform2D_class, rb_intern("_adopt"), 1, LONG2NUM((long)naddr));
  return obj;
}
godot_transform2d * rb_godot_transform2d_pointer_to_godot (VALUE self) {
  VALUE addr = rb_iv_get(self, "@_godot_address");
  return (godot_transform2d *)NUM2LONG(addr);
}
VALUE rb_godot_vector2_from_godot (godot_vector2 addr) {
  return rb_godot_vector2_pointer_from_godot(&addr);
}
godot_vector2 rb_godot_vector2_to_godot (VALUE self) {
  return *rb_godot_vector2_pointer_to_godot(self);
}
VALUE rb_godot_vector2_pointer_from_godot (godot_vector2 * addr) {
  godot_vector2 * naddr = api->godot_alloc(sizeof(godot_vector2 ));
  memcpy(naddr, addr, sizeof(godot_vector2 ));
  VALUE obj = rb_funcall(Vector2_class, rb_intern("_adopt"), 1, LONG2NUM((long)naddr));
  return obj;
}
godot_vector2 * rb_godot_vector2_pointer_to_godot (VALUE self) {
  VALUE addr = rb_iv_get(self, "@_godot_address");
  return (godot_vector2 *)NUM2LONG(addr);
}
VALUE rb_godot_vector3_from_godot (godot_vector3 addr) {
  return rb_godot_vector3_pointer_from_godot(&addr);
}
godot_vector3 rb_godot_vector3_to_godot (VALUE self) {
  return *rb_godot_vector3_pointer_to_godot(self);
}
VALUE rb_godot_vector3_pointer_from_godot (godot_vector3 * addr) {
  godot_vector3 * naddr = api->godot_alloc(sizeof(godot_vector3 ));
  memcpy(naddr, addr, sizeof(godot_vector3 ));
  VALUE obj = rb_funcall(Vector3_class, rb_intern("_adopt"), 1, LONG2NUM((long)naddr));
  return obj;
}
godot_vector3 * rb_godot_vector3_pointer_to_godot (VALUE self) {
  VALUE addr = rb_iv_get(self, "@_godot_address");
  return (godot_vector3 *)NUM2LONG(addr);
}
VALUE rb_godot_node_path_from_godot (godot_node_path addr) {
  return rb_godot_node_path_pointer_from_godot(&addr);
}
godot_node_path rb_godot_node_path_to_godot (VALUE self) {
  return *rb_godot_node_path_pointer_to_godot(self);
}
VALUE rb_godot_node_path_pointer_from_godot (godot_node_path * addr) {
  godot_node_path * naddr = api->godot_alloc(sizeof(godot_node_path ));
  memcpy(naddr, addr, sizeof(godot_node_path ));
  // will copy increase the reference count?
  // api->godot_node_path_new_copy(naddr, addr);
  VALUE obj = rb_funcall(NodePath_class, rb_intern("_adopt"), 1, LONG2NUM((long)naddr));
  return obj;
}
godot_node_path * rb_godot_node_path_pointer_to_godot (VALUE self) {
  VALUE addr = rb_iv_get(self, "@_godot_address");
  return (godot_node_path *)NUM2LONG(addr);
}
VALUE rb_godot_array_from_godot (godot_array addr) {
  return rb_godot_array_pointer_from_godot(&addr);
}
godot_array rb_godot_array_to_godot (VALUE self) {
  return *rb_godot_array_pointer_to_godot(self);
}
VALUE rb_godot_array_pointer_from_godot (godot_array * addr) {
  godot_array * naddr = api->godot_alloc(sizeof(godot_array ));
  memcpy(naddr, addr, sizeof(godot_array ));
  // will copy increase the reference count?
  // api->godot_array_new_copy(naddr, addr);
  VALUE obj = rb_funcall(Array_class, rb_intern("_adopt"), 1, LONG2NUM((long)naddr));
  return obj;
}
godot_array * rb_godot_array_pointer_to_godot (VALUE self) {
  VALUE addr = rb_iv_get(self, "@_godot_address");
  return (godot_array *)NUM2LONG(addr);
}
VALUE rb_godot_dictionary_from_godot (godot_dictionary addr) {
  return rb_godot_dictionary_pointer_from_godot(&addr);
}
godot_dictionary rb_godot_dictionary_to_godot (VALUE self) {
  return *rb_godot_dictionary_pointer_to_godot(self);
}
VALUE rb_godot_dictionary_pointer_from_godot (godot_dictionary * addr) {
  godot_dictionary * naddr = api->godot_alloc(sizeof(godot_dictionary ));
  memcpy(naddr, addr, sizeof(godot_dictionary ));
  // will copy increase the reference count?
  // api->godot_dictionary_new_copy(naddr, addr);
  VALUE obj = rb_funcall(Dictionary_class, rb_intern("_adopt"), 1, LONG2NUM((long)naddr));
  return obj;
}
godot_dictionary * rb_godot_dictionary_pointer_to_godot (VALUE self) {
  VALUE addr = rb_iv_get(self, "@_godot_address");
  return (godot_dictionary *)NUM2LONG(addr);
}
VALUE rb_godot_object_pointer_from_godot (godot_object * addr) {
  VALUE obj = rb_funcall(Object_class, rb_intern("_adopt"), 1, LONG2NUM((long)addr));
  return obj;
}
godot_object * rb_godot_object_pointer_to_godot (VALUE self) {
  VALUE addr = rb_iv_get(self, "@_godot_address");
  return (godot_object *)NUM2LONG(addr);
}
VALUE rb_godot_pool_string_array_from_godot (godot_pool_string_array addr) {
  return rb_godot_pool_string_array_pointer_from_godot(&addr);
}
godot_pool_string_array rb_godot_pool_string_array_to_godot (VALUE self) {
  return *rb_godot_pool_string_array_pointer_to_godot(self);
}
VALUE rb_godot_pool_string_array_pointer_from_godot (godot_pool_string_array * addr) {
  godot_pool_string_array * naddr = api->godot_alloc(sizeof(godot_pool_string_array ));
  memcpy(naddr, addr, sizeof(godot_pool_string_array ));
  // will copy increase the reference count?
  // api->godot_pool_string_array_new_copy(naddr, addr);
  VALUE obj = rb_funcall(PoolStringArray_class, rb_intern("_adopt"), 1, LONG2NUM((long)naddr));
  return obj;
}
godot_pool_string_array * rb_godot_pool_string_array_pointer_to_godot (VALUE self) {
  VALUE addr = rb_iv_get(self, "@_godot_address");
  return (godot_pool_string_array *)NUM2LONG(addr);
}
VALUE rb_godot_variant_from_godot (godot_variant addr) {
  VALUE ret;
  switch (api->godot_variant_get_type(&addr)) {
    case GODOT_VARIANT_TYPE_NIL:
      ret = Qnil;
      break;
    case GODOT_VARIANT_TYPE_BOOL:
      ret = rb_godot_bool_from_godot((api->godot_variant_as_bool(&addr)));
      break;
    case GODOT_VARIANT_TYPE_INT:
      ret = rb_godot_int_from_godot((api->godot_variant_as_int(&addr)));
      break;
    case GODOT_VARIANT_TYPE_REAL:
      ret = rb_godot_real_from_godot((api->godot_variant_as_real(&addr)));
      break;
    case GODOT_VARIANT_TYPE_AABB: {
  godot_aabb val = api->godot_variant_as_aabb(&addr);
  ret = rb_godot_aabb_from_godot(val);
  break;
}

case GODOT_VARIANT_TYPE_BASIS: {
  godot_basis val = api->godot_variant_as_basis(&addr);
  ret = rb_godot_basis_from_godot(val);
  break;
}

case GODOT_VARIANT_TYPE_COLOR: {
  godot_color val = api->godot_variant_as_color(&addr);
  ret = rb_godot_color_from_godot(val);
  break;
}

case GODOT_VARIANT_TYPE_PLANE: {
  godot_plane val = api->godot_variant_as_plane(&addr);
  ret = rb_godot_plane_from_godot(val);
  break;
}

case GODOT_VARIANT_TYPE_QUAT: {
  godot_quat val = api->godot_variant_as_quat(&addr);
  ret = rb_godot_quat_from_godot(val);
  break;
}

case GODOT_VARIANT_TYPE_RECT2: {
  godot_rect2 val = api->godot_variant_as_rect2(&addr);
  ret = rb_godot_rect2_from_godot(val);
  break;
}

case GODOT_VARIANT_TYPE_TRANSFORM: {
  godot_transform val = api->godot_variant_as_transform(&addr);
  ret = rb_godot_transform_from_godot(val);
  break;
}

case GODOT_VARIANT_TYPE_TRANSFORM2D: {
  godot_transform2d val = api->godot_variant_as_transform2d(&addr);
  ret = rb_godot_transform2d_from_godot(val);
  break;
}

case GODOT_VARIANT_TYPE_VECTOR2: {
  godot_vector2 val = api->godot_variant_as_vector2(&addr);
  ret = rb_godot_vector2_from_godot(val);
  break;
}

case GODOT_VARIANT_TYPE_VECTOR3: {
  godot_vector3 val = api->godot_variant_as_vector3(&addr);
  ret = rb_godot_vector3_from_godot(val);
  break;
}

case GODOT_VARIANT_TYPE_ARRAY: {
  godot_array val = api->godot_variant_as_array(&addr);
  ret = rb_godot_array_from_godot(val);
  break;
}

case GODOT_VARIANT_TYPE_DICTIONARY: {
  godot_dictionary val = api->godot_variant_as_dictionary(&addr);
  ret = rb_godot_dictionary_from_godot(val);
  break;
}

case GODOT_VARIANT_TYPE_NODE_PATH: {
  godot_node_path val = api->godot_variant_as_node_path(&addr);
  ret = rb_godot_node_path_from_godot(val);
  break;
}

case GODOT_VARIANT_TYPE_OBJECT: {
  godot_object* val = api->godot_variant_as_object(&addr);
  ret = rb_godot_object_pointer_from_godot(val);
  break;
}

case GODOT_VARIANT_TYPE_POOL_STRING_ARRAY: {
  godot_pool_string_array val = api->godot_variant_as_pool_string_array(&addr);
  ret = rb_godot_pool_string_array_from_godot(val);
  break;
}

case GODOT_VARIANT_TYPE_STRING: {
  godot_string val = api->godot_variant_as_string(&addr);
  ret = rb_godot_string_from_godot(val);
  break;
}

  }
  api->godot_variant_destroy(&addr);
  return ret;
}
godot_variant rb_godot_variant_to_godot (VALUE self) {
  godot_variant var;
  switch (TYPE(self)) {
    case T_NIL: {
      api->godot_variant_new_nil(&var);
      break;
    }
    case T_TRUE: {
      api->godot_variant_new_bool(&var, 1);
      break;
    }
    case T_FALSE: {
      api->godot_variant_new_bool(&var, 0);
      break;
    }
    case T_FIXNUM: {
      api->godot_variant_new_int(&var, FIX2LONG(self));
      break;
    }
    case T_STRING: {
      VALUE r_str = rb_funcall(String_class, rb_intern("new"), 1, self);
      godot_string *str = rb_godot_string_pointer_to_godot(r_str);
      api->godot_variant_new_string(&var, str);
      break;
    }
    case T_FLOAT: {
      api->godot_variant_new_real(&var, RFLOAT_VALUE(self));
      break;
    }
    case T_SYMBOL: {
      VALUE _str = rb_funcall(self, rb_intern("to_s"), 0);
      VALUE r_str = rb_funcall(String_class, rb_intern("new"), 1, _str);
      godot_string *str = rb_godot_string_pointer_to_godot(r_str);
      api->godot_variant_new_string(&var, str);
      break;
    }
    case T_ARRAY: {
      VALUE r_ary = rb_funcall(Array_class, rb_intern("new"), 1, self);
      godot_array *ary = rb_godot_array_pointer_to_godot(r_ary);
      api->godot_variant_new_array(&var, ary);
      break;
    }
    case T_HASH: {
      VALUE hsh = rb_funcall(Dictionary_class, rb_intern("new"), 1, self);
      godot_dictionary *dict = rb_godot_dictionary_pointer_to_godot(hsh);
      api->godot_variant_new_dictionary(&var, dict);
      break;
    }
    default: {
      VALUE godot_module = rb_const_get(rb_cModule, rb_intern("Godot"));
      VALUE built_in_type_class = rb_funcall(godot_module, rb_intern("built_in_type_class"), 0);

      if (RTEST(rb_funcall(self, rb_intern("is_a?"), 1, built_in_type_class))) {
        switch (FIX2LONG(rb_funcall(self, rb_intern("_type"), 0))) {
          case GODOT_VARIANT_TYPE_AABB: {
  godot_aabb *addr = rb_godot_aabb_pointer_to_godot(self);
  api->godot_variant_new_aabb(&var, addr);
  break;
}

case GODOT_VARIANT_TYPE_BASIS: {
  godot_basis *addr = rb_godot_basis_pointer_to_godot(self);
  api->godot_variant_new_basis(&var, addr);
  break;
}

case GODOT_VARIANT_TYPE_COLOR: {
  godot_color *addr = rb_godot_color_pointer_to_godot(self);
  api->godot_variant_new_color(&var, addr);
  break;
}

case GODOT_VARIANT_TYPE_PLANE: {
  godot_plane *addr = rb_godot_plane_pointer_to_godot(self);
  api->godot_variant_new_plane(&var, addr);
  break;
}

case GODOT_VARIANT_TYPE_QUAT: {
  godot_quat *addr = rb_godot_quat_pointer_to_godot(self);
  api->godot_variant_new_quat(&var, addr);
  break;
}

case GODOT_VARIANT_TYPE_RECT2: {
  godot_rect2 *addr = rb_godot_rect2_pointer_to_godot(self);
  api->godot_variant_new_rect2(&var, addr);
  break;
}

case GODOT_VARIANT_TYPE_TRANSFORM: {
  godot_transform *addr = rb_godot_transform_pointer_to_godot(self);
  api->godot_variant_new_transform(&var, addr);
  break;
}

case GODOT_VARIANT_TYPE_TRANSFORM2D: {
  godot_transform2d *addr = rb_godot_transform2d_pointer_to_godot(self);
  api->godot_variant_new_transform2d(&var, addr);
  break;
}

case GODOT_VARIANT_TYPE_VECTOR2: {
  godot_vector2 *addr = rb_godot_vector2_pointer_to_godot(self);
  api->godot_variant_new_vector2(&var, addr);
  break;
}

case GODOT_VARIANT_TYPE_VECTOR3: {
  godot_vector3 *addr = rb_godot_vector3_pointer_to_godot(self);
  api->godot_variant_new_vector3(&var, addr);
  break;
}

case GODOT_VARIANT_TYPE_ARRAY: {
  godot_array *addr = rb_godot_array_pointer_to_godot(self);
  api->godot_variant_new_array(&var, addr);
  break;
}

case GODOT_VARIANT_TYPE_DICTIONARY: {
  godot_dictionary *addr = rb_godot_dictionary_pointer_to_godot(self);
  api->godot_variant_new_dictionary(&var, addr);
  break;
}

case GODOT_VARIANT_TYPE_NODE_PATH: {
  godot_node_path *addr = rb_godot_node_path_pointer_to_godot(self);
  api->godot_variant_new_node_path(&var, addr);
  break;
}

case GODOT_VARIANT_TYPE_OBJECT: {
  godot_object *addr = rb_godot_object_pointer_to_godot(self);
  api->godot_variant_new_object(&var, addr);
  break;
}

case GODOT_VARIANT_TYPE_POOL_STRING_ARRAY: {
  godot_pool_string_array *addr = rb_godot_pool_string_array_pointer_to_godot(self);
  api->godot_variant_new_pool_string_array(&var, addr);
  break;
}

case GODOT_VARIANT_TYPE_STRING: {
  godot_string *addr = rb_godot_string_pointer_to_godot(self);
  api->godot_variant_new_string(&var, addr);
  break;
}

          default: {
            api->godot_print_error("unknown variant type", "", __FILE__, __LINE__);
            api->godot_variant_new_nil(&var);
          }
        }
      } else {
        VALUE _str = rb_funcall(self, rb_intern("to_s"), 0);
        VALUE r_str = rb_funcall(String_class, rb_intern("new"), 1, _str);
        godot_string *str = rb_godot_string_pointer_to_godot(r_str);
        api->godot_variant_new_string(&var, str);
      }
    }
  }

  return var;
}
VALUE rb_godot_variant_pointer_from_godot (godot_variant * addr) {
  return rb_godot_variant_from_godot(*addr);
}
VALUE rb_wchar_t_pointer_from_godot (wchar_t *addr) {
  godot_string str;
  api->godot_string_new_with_wide_string(&str, addr, 1);
  VALUE obj = rb_funcall(String_class, rb_intern("_adopt"), 1, LONG2NUM((long)&str));
  return obj;
}
VALUE rb_wchar_t_from_godot (wchar_t addr) {
  return rb_wchar_t_pointer_from_godot(&addr);
}
wchar_t rb_wchar_t_to_godot (VALUE self) {
  return NUM2DBL(self);
}
VALUE rb_godot_aabb_initialize(VALUE self, VALUE p_pos, VALUE p_size){
  godot_aabb *addr = api->godot_alloc(sizeof(godot_aabb));
  api->godot_aabb_new(addr, rb_godot_vector3_pointer_to_godot(p_pos), rb_godot_vector3_pointer_to_godot(p_size));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}
VALUE rb_godot_basis_initialize_with_rows(VALUE self, VALUE p_x_axis, VALUE p_y_axis, VALUE p_z_axis){
  godot_basis *addr = api->godot_alloc(sizeof(godot_basis));
  api->godot_basis_new_with_rows(addr, rb_godot_vector3_pointer_to_godot(p_x_axis), rb_godot_vector3_pointer_to_godot(p_y_axis), rb_godot_vector3_pointer_to_godot(p_z_axis));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}

VALUE rb_godot_basis_initialize_with_axis_and_angle(VALUE self, VALUE p_axis, VALUE p_phi){
  godot_basis *addr = api->godot_alloc(sizeof(godot_basis));
  api->godot_basis_new_with_axis_and_angle(addr, rb_godot_vector3_pointer_to_godot(p_axis), rb_godot_real_to_godot(p_phi));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}

VALUE rb_godot_basis_initialize_with_euler(VALUE self, VALUE p_euler){
  godot_basis *addr = api->godot_alloc(sizeof(godot_basis));
  api->godot_basis_new_with_euler(addr, rb_godot_vector3_pointer_to_godot(p_euler));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}

VALUE rb_godot_basis_initialize_with_euler_quat(VALUE self, VALUE p_euler){
  godot_basis *addr = api->godot_alloc(sizeof(godot_basis));
  api->godot_basis_new_with_euler_quat(addr, rb_godot_quat_pointer_to_godot(p_euler));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}
VALUE rb_godot_color_initialize_rgba(VALUE self, VALUE p_r, VALUE p_g, VALUE p_b, VALUE p_a){
  godot_color *addr = api->godot_alloc(sizeof(godot_color));
  api->godot_color_new_rgba(addr, rb_godot_real_to_godot(p_r), rb_godot_real_to_godot(p_g), rb_godot_real_to_godot(p_b), rb_godot_real_to_godot(p_a));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}

VALUE rb_godot_color_initialize_rgb(VALUE self, VALUE p_r, VALUE p_g, VALUE p_b){
  godot_color *addr = api->godot_alloc(sizeof(godot_color));
  api->godot_color_new_rgb(addr, rb_godot_real_to_godot(p_r), rb_godot_real_to_godot(p_g), rb_godot_real_to_godot(p_b));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}
VALUE rb_godot_plane_initialize_with_reals(VALUE self, VALUE p_a, VALUE p_b, VALUE p_c, VALUE p_d){
  godot_plane *addr = api->godot_alloc(sizeof(godot_plane));
  api->godot_plane_new_with_reals(addr, rb_godot_real_to_godot(p_a), rb_godot_real_to_godot(p_b), rb_godot_real_to_godot(p_c), rb_godot_real_to_godot(p_d));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}

VALUE rb_godot_plane_initialize_with_vectors(VALUE self, VALUE p_v1, VALUE p_v2, VALUE p_v3){
  godot_plane *addr = api->godot_alloc(sizeof(godot_plane));
  api->godot_plane_new_with_vectors(addr, rb_godot_vector3_pointer_to_godot(p_v1), rb_godot_vector3_pointer_to_godot(p_v2), rb_godot_vector3_pointer_to_godot(p_v3));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}

VALUE rb_godot_plane_initialize_with_normal(VALUE self, VALUE p_normal, VALUE p_d){
  godot_plane *addr = api->godot_alloc(sizeof(godot_plane));
  api->godot_plane_new_with_normal(addr, rb_godot_vector3_pointer_to_godot(p_normal), rb_godot_real_to_godot(p_d));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}
VALUE rb_godot_quat_initialize(VALUE self, VALUE p_x, VALUE p_y, VALUE p_z, VALUE p_w){
  godot_quat *addr = api->godot_alloc(sizeof(godot_quat));
  api->godot_quat_new(addr, rb_godot_real_to_godot(p_x), rb_godot_real_to_godot(p_y), rb_godot_real_to_godot(p_z), rb_godot_real_to_godot(p_w));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}

VALUE rb_godot_quat_initialize_with_axis_angle(VALUE self, VALUE p_axis, VALUE p_angle){
  godot_quat *addr = api->godot_alloc(sizeof(godot_quat));
  api->godot_quat_new_with_axis_angle(addr, rb_godot_vector3_pointer_to_godot(p_axis), rb_godot_real_to_godot(p_angle));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}
VALUE rb_godot_rect2_initialize_with_position_and_size(VALUE self, VALUE p_pos, VALUE p_size){
  godot_rect2 *addr = api->godot_alloc(sizeof(godot_rect2));
  api->godot_rect2_new_with_position_and_size(addr, rb_godot_vector2_pointer_to_godot(p_pos), rb_godot_vector2_pointer_to_godot(p_size));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}

VALUE rb_godot_rect2_initialize(VALUE self, VALUE p_x, VALUE p_y, VALUE p_width, VALUE p_height){
  godot_rect2 *addr = api->godot_alloc(sizeof(godot_rect2));
  api->godot_rect2_new(addr, rb_godot_real_to_godot(p_x), rb_godot_real_to_godot(p_y), rb_godot_real_to_godot(p_width), rb_godot_real_to_godot(p_height));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}
VALUE rb_godot_transform_initialize_with_axis_origin(VALUE self, VALUE p_x_axis, VALUE p_y_axis, VALUE p_z_axis, VALUE p_origin){
  godot_transform *addr = api->godot_alloc(sizeof(godot_transform));
  api->godot_transform_new_with_axis_origin(addr, rb_godot_vector3_pointer_to_godot(p_x_axis), rb_godot_vector3_pointer_to_godot(p_y_axis), rb_godot_vector3_pointer_to_godot(p_z_axis), rb_godot_vector3_pointer_to_godot(p_origin));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}

VALUE rb_godot_transform_initialize(VALUE self, VALUE p_basis, VALUE p_origin){
  godot_transform *addr = api->godot_alloc(sizeof(godot_transform));
  api->godot_transform_new(addr, rb_godot_basis_pointer_to_godot(p_basis), rb_godot_vector3_pointer_to_godot(p_origin));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}
VALUE rb_godot_transform2d_initialize(VALUE self, VALUE p_rot, VALUE p_pos){
  godot_transform2d *addr = api->godot_alloc(sizeof(godot_transform2d));
  api->godot_transform2d_new(addr, rb_godot_real_to_godot(p_rot), rb_godot_vector2_pointer_to_godot(p_pos));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}

VALUE rb_godot_transform2d_initialize_axis_origin(VALUE self, VALUE p_x_axis, VALUE p_y_axis, VALUE p_origin){
  godot_transform2d *addr = api->godot_alloc(sizeof(godot_transform2d));
  api->godot_transform2d_new_axis_origin(addr, rb_godot_vector2_pointer_to_godot(p_x_axis), rb_godot_vector2_pointer_to_godot(p_y_axis), rb_godot_vector2_pointer_to_godot(p_origin));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}
VALUE rb_godot_vector2_initialize(VALUE self, VALUE p_x, VALUE p_y){
  godot_vector2 *addr = api->godot_alloc(sizeof(godot_vector2));
  api->godot_vector2_new(addr, rb_godot_real_to_godot(p_x), rb_godot_real_to_godot(p_y));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}
VALUE rb_godot_vector3_initialize(VALUE self, VALUE p_x, VALUE p_y, VALUE p_z){
  godot_vector3 *addr = api->godot_alloc(sizeof(godot_vector3));
  api->godot_vector3_new(addr, rb_godot_real_to_godot(p_x), rb_godot_real_to_godot(p_y), rb_godot_real_to_godot(p_z));
  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}
VALUE rb_godot_array_initialize(VALUE self, VALUE value){
  godot_array *addr = api->godot_alloc(sizeof(godot_array));
  api->godot_array_new(addr);

for (int i=0; i < RARRAY_LEN(value); ++i) {
  godot_variant var = rb_godot_variant_to_godot(RARRAY_AREF(value, i));
  api->godot_array_append(addr, &var);
  api->godot_variant_destroy(&var);
}

  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}
VALUE rb_godot_dictionary_initialize(VALUE self, VALUE value){
  godot_dictionary *addr = api->godot_alloc(sizeof(godot_dictionary));
  api->godot_dictionary_new(addr);

VALUE pairs = rb_funcall(value, rb_intern("to_a"), 0);

for (int i=0; i < RARRAY_LEN(pairs); ++i) {
  godot_variant key, value;
  VALUE pair = RARRAY_AREF(pairs, i);
  key = rb_godot_variant_to_godot(RARRAY_AREF(pair, 0));
  value = rb_godot_variant_to_godot(RARRAY_AREF(pair, 1));
  api->godot_dictionary_set(addr, &key, &value);
  api->godot_variant_destroy(&key);
  api->godot_variant_destroy(&value);
}

  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}
VALUE rb_godot_node_path_initialize(VALUE self, VALUE value){
  godot_node_path *addr = api->godot_alloc(sizeof(godot_node_path));
  godot_string temp;
VALUE is_godot_string = rb_funcall(value, rb_intern("is_a?"), 1, String_class);
if (RTEST(is_godot_string)) {
  api->godot_string_new_copy(&temp, rb_godot_string_pointer_to_godot(value));
} else {
  api->godot_string_new(&temp);
  char* str = StringValuePtr(value);
  int len = RSTRING_LEN(value);

  api->godot_string_parse_utf8_with_len(&temp, str, len);
}

api->godot_node_path_new(addr, &temp);
api->godot_string_destroy(&temp);

  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}
VALUE rb_godot_pool_string_array_initialize(VALUE self, VALUE value){
  godot_pool_string_array *addr = api->godot_alloc(sizeof(godot_pool_string_array));
  api->godot_pool_string_array_new(addr);

for (int i=0; i < RARRAY_LEN(value); ++i) {
  godot_string *str = rb_godot_string_pointer_to_godot(RARRAY_AREF(value, i));
  api->godot_pool_string_array_append(addr, str);
}

  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}
VALUE rb_godot_string_initialize(VALUE self, VALUE value){
  godot_string *addr = api->godot_alloc(sizeof(godot_string));
  VALUE is_godot_string = rb_funcall(value, rb_intern("is_a?"), 1, String_class);
if (RTEST(is_godot_string)) {
  api->godot_string_new_copy(addr, rb_godot_string_pointer_to_godot(value));
} else {
  api->godot_string_new(addr);
  char* str = StringValuePtr(value);
  int len = RSTRING_LEN(value);

  api->godot_string_parse_utf8_with_len(addr, str, len);
}

  return rb_iv_set(self, "@_godot_address", LONG2NUM((long)addr));
}
VALUE rb_godot_aabb_finalize (VALUE self, VALUE addr) {
  api->godot_free((void*)NUM2LONG(addr));
  return Qtrue;
}
VALUE rb_godot_basis_finalize (VALUE self, VALUE addr) {
  api->godot_free((void*)NUM2LONG(addr));
  return Qtrue;
}
VALUE rb_godot_color_finalize (VALUE self, VALUE addr) {
  api->godot_free((void*)NUM2LONG(addr));
  return Qtrue;
}
VALUE rb_godot_plane_finalize (VALUE self, VALUE addr) {
  api->godot_free((void*)NUM2LONG(addr));
  return Qtrue;
}
VALUE rb_godot_quat_finalize (VALUE self, VALUE addr) {
  api->godot_free((void*)NUM2LONG(addr));
  return Qtrue;
}
VALUE rb_godot_rect2_finalize (VALUE self, VALUE addr) {
  api->godot_free((void*)NUM2LONG(addr));
  return Qtrue;
}
VALUE rb_godot_transform_finalize (VALUE self, VALUE addr) {
  api->godot_free((void*)NUM2LONG(addr));
  return Qtrue;
}
VALUE rb_godot_transform2d_finalize (VALUE self, VALUE addr) {
  api->godot_free((void*)NUM2LONG(addr));
  return Qtrue;
}
VALUE rb_godot_vector2_finalize (VALUE self, VALUE addr) {
  api->godot_free((void*)NUM2LONG(addr));
  return Qtrue;
}
VALUE rb_godot_vector3_finalize (VALUE self, VALUE addr) {
  api->godot_free((void*)NUM2LONG(addr));
  return Qtrue;
}
VALUE rb_godot_array_finalize (VALUE self, VALUE addr) {
  api->godot_array_destroy((godot_array*)NUM2LONG(addr));
  api->godot_free((void*)NUM2LONG(addr));
  return Qtrue;
}
VALUE rb_godot_dictionary_finalize (VALUE self, VALUE addr) {
  api->godot_dictionary_destroy((godot_dictionary*)NUM2LONG(addr));
  api->godot_free((void*)NUM2LONG(addr));
  return Qtrue;
}
VALUE rb_godot_node_path_finalize (VALUE self, VALUE addr) {
  api->godot_node_path_destroy((godot_node_path*)NUM2LONG(addr));
  api->godot_free((void*)NUM2LONG(addr));
  return Qtrue;
}
VALUE rb_godot_object_finalize (VALUE self, VALUE addr) {
  api->godot_object_destroy((godot_object*)NUM2LONG(addr));
  api->godot_free((void*)NUM2LONG(addr));
  return Qtrue;
}
VALUE rb_godot_pool_string_array_finalize (VALUE self, VALUE addr) {
  api->godot_pool_string_array_destroy((godot_pool_string_array*)NUM2LONG(addr));
  api->godot_free((void*)NUM2LONG(addr));
  return Qtrue;
}
VALUE rb_godot_string_finalize (VALUE self, VALUE addr) {
  api->godot_string_destroy((godot_string*)NUM2LONG(addr));
  api->godot_free((void*)NUM2LONG(addr));
  return Qtrue;
}
VALUE rb_godot_aabb_get_position (VALUE p_self) {
  
  godot_vector3 value = api->godot_aabb_get_position(rb_godot_aabb_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_set_position (VALUE p_self, VALUE p_v) {
  
  api->godot_aabb_set_position(rb_godot_aabb_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_v));
  
  return Qnil;
}
VALUE rb_godot_aabb_get_size (VALUE p_self) {
  
  godot_vector3 value = api->godot_aabb_get_size(rb_godot_aabb_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_set_size (VALUE p_self, VALUE p_v) {
  
  api->godot_aabb_set_size(rb_godot_aabb_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_v));
  
  return Qnil;
}
VALUE rb_godot_aabb_as_string (VALUE p_self) {
  
  godot_string value = api->godot_aabb_as_string(rb_godot_aabb_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_get_area (VALUE p_self) {
  
  godot_real value = api->godot_aabb_get_area(rb_godot_aabb_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_has_no_area (VALUE p_self) {
  
  godot_bool value = api->godot_aabb_has_no_area(rb_godot_aabb_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_has_no_surface (VALUE p_self) {
  
  godot_bool value = api->godot_aabb_has_no_surface(rb_godot_aabb_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_intersects (VALUE p_self, VALUE p_with) {
  
  godot_bool value = api->godot_aabb_intersects(rb_godot_aabb_pointer_to_godot(p_self), rb_godot_aabb_pointer_to_godot(p_with));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_encloses (VALUE p_self, VALUE p_with) {
  
  godot_bool value = api->godot_aabb_encloses(rb_godot_aabb_pointer_to_godot(p_self), rb_godot_aabb_pointer_to_godot(p_with));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_merge (VALUE p_self, VALUE p_with) {
  
  godot_aabb value = api->godot_aabb_merge(rb_godot_aabb_pointer_to_godot(p_self), rb_godot_aabb_pointer_to_godot(p_with));
  VALUE ret = rb_godot_aabb_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_intersection (VALUE p_self, VALUE p_with) {
  
  godot_aabb value = api->godot_aabb_intersection(rb_godot_aabb_pointer_to_godot(p_self), rb_godot_aabb_pointer_to_godot(p_with));
  VALUE ret = rb_godot_aabb_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_intersects_plane (VALUE p_self, VALUE p_plane) {
  
  godot_bool value = api->godot_aabb_intersects_plane(rb_godot_aabb_pointer_to_godot(p_self), rb_godot_plane_pointer_to_godot(p_plane));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_intersects_segment (VALUE p_self, VALUE p_from, VALUE p_to) {
  
  godot_bool value = api->godot_aabb_intersects_segment(rb_godot_aabb_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_from), rb_godot_vector3_pointer_to_godot(p_to));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_has_point (VALUE p_self, VALUE p_point) {
  
  godot_bool value = api->godot_aabb_has_point(rb_godot_aabb_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_point));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_get_support (VALUE p_self, VALUE p_dir) {
  
  godot_vector3 value = api->godot_aabb_get_support(rb_godot_aabb_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_dir));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_get_longest_axis (VALUE p_self) {
  
  godot_vector3 value = api->godot_aabb_get_longest_axis(rb_godot_aabb_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_get_longest_axis_index (VALUE p_self) {
  
  godot_int value = api->godot_aabb_get_longest_axis_index(rb_godot_aabb_pointer_to_godot(p_self));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_get_longest_axis_size (VALUE p_self) {
  
  godot_real value = api->godot_aabb_get_longest_axis_size(rb_godot_aabb_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_get_shortest_axis (VALUE p_self) {
  
  godot_vector3 value = api->godot_aabb_get_shortest_axis(rb_godot_aabb_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_get_shortest_axis_index (VALUE p_self) {
  
  godot_int value = api->godot_aabb_get_shortest_axis_index(rb_godot_aabb_pointer_to_godot(p_self));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_get_shortest_axis_size (VALUE p_self) {
  
  godot_real value = api->godot_aabb_get_shortest_axis_size(rb_godot_aabb_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_expand (VALUE p_self, VALUE p_to_point) {
  
  godot_aabb value = api->godot_aabb_expand(rb_godot_aabb_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_to_point));
  VALUE ret = rb_godot_aabb_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_grow (VALUE p_self, VALUE p_by) {
  
  godot_aabb value = api->godot_aabb_grow(rb_godot_aabb_pointer_to_godot(p_self), rb_godot_real_to_godot(p_by));
  VALUE ret = rb_godot_aabb_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_get_endpoint (VALUE p_self, VALUE p_idx) {
  
  godot_vector3 value = api->godot_aabb_get_endpoint(rb_godot_aabb_pointer_to_godot(p_self), rb_godot_int_to_godot(p_idx));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_aabb_operator_equal (VALUE p_self, VALUE p_b) {
  
  godot_bool value = api->godot_aabb_operator_equal(rb_godot_aabb_pointer_to_godot(p_self), rb_godot_aabb_pointer_to_godot(p_b));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_as_string (VALUE p_self) {
  
  godot_string value = api->godot_basis_as_string(rb_godot_basis_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_inverse (VALUE p_self) {
  
  godot_basis value = api->godot_basis_inverse(rb_godot_basis_pointer_to_godot(p_self));
  VALUE ret = rb_godot_basis_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_transposed (VALUE p_self) {
  
  godot_basis value = api->godot_basis_transposed(rb_godot_basis_pointer_to_godot(p_self));
  VALUE ret = rb_godot_basis_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_orthonormalized (VALUE p_self) {
  
  godot_basis value = api->godot_basis_orthonormalized(rb_godot_basis_pointer_to_godot(p_self));
  VALUE ret = rb_godot_basis_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_determinant (VALUE p_self) {
  
  godot_real value = api->godot_basis_determinant(rb_godot_basis_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_rotated (VALUE p_self, VALUE p_axis, VALUE p_phi) {
  
  godot_basis value = api->godot_basis_rotated(rb_godot_basis_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_axis), rb_godot_real_to_godot(p_phi));
  VALUE ret = rb_godot_basis_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_scaled (VALUE p_self, VALUE p_scale) {
  
  godot_basis value = api->godot_basis_scaled(rb_godot_basis_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_scale));
  VALUE ret = rb_godot_basis_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_get_scale (VALUE p_self) {
  
  godot_vector3 value = api->godot_basis_get_scale(rb_godot_basis_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_get_euler (VALUE p_self) {
  
  godot_vector3 value = api->godot_basis_get_euler(rb_godot_basis_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_tdotx (VALUE p_self, VALUE p_with) {
  
  godot_real value = api->godot_basis_tdotx(rb_godot_basis_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_with));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_tdoty (VALUE p_self, VALUE p_with) {
  
  godot_real value = api->godot_basis_tdoty(rb_godot_basis_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_with));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_tdotz (VALUE p_self, VALUE p_with) {
  
  godot_real value = api->godot_basis_tdotz(rb_godot_basis_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_with));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_xform (VALUE p_self, VALUE p_v) {
  
  godot_vector3 value = api->godot_basis_xform(rb_godot_basis_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_v));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_xform_inv (VALUE p_self, VALUE p_v) {
  
  godot_vector3 value = api->godot_basis_xform_inv(rb_godot_basis_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_v));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_get_orthogonal_index (VALUE p_self) {
  
  godot_int value = api->godot_basis_get_orthogonal_index(rb_godot_basis_pointer_to_godot(p_self));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_get_elements (VALUE p_self, VALUE p_elements) {
  
  api->godot_basis_get_elements(rb_godot_basis_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_elements));
  
  return Qnil;
}
VALUE rb_godot_basis_get_axis (VALUE p_self, VALUE p_axis) {
  
  godot_vector3 value = api->godot_basis_get_axis(rb_godot_basis_pointer_to_godot(p_self), rb_godot_int_to_godot(p_axis));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_set_axis (VALUE p_self, VALUE p_axis, VALUE p_value) {
  
  api->godot_basis_set_axis(rb_godot_basis_pointer_to_godot(p_self), rb_godot_int_to_godot(p_axis), rb_godot_vector3_pointer_to_godot(p_value));
  
  return Qnil;
}
VALUE rb_godot_basis_get_row (VALUE p_self, VALUE p_row) {
  
  godot_vector3 value = api->godot_basis_get_row(rb_godot_basis_pointer_to_godot(p_self), rb_godot_int_to_godot(p_row));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_set_row (VALUE p_self, VALUE p_row, VALUE p_value) {
  
  api->godot_basis_set_row(rb_godot_basis_pointer_to_godot(p_self), rb_godot_int_to_godot(p_row), rb_godot_vector3_pointer_to_godot(p_value));
  
  return Qnil;
}
VALUE rb_godot_basis_operator_equal (VALUE p_self, VALUE p_b) {
  
  godot_bool value = api->godot_basis_operator_equal(rb_godot_basis_pointer_to_godot(p_self), rb_godot_basis_pointer_to_godot(p_b));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_operator_add (VALUE p_self, VALUE p_b) {
  
  godot_basis value = api->godot_basis_operator_add(rb_godot_basis_pointer_to_godot(p_self), rb_godot_basis_pointer_to_godot(p_b));
  VALUE ret = rb_godot_basis_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_operator_subtract (VALUE p_self, VALUE p_b) {
  
  godot_basis value = api->godot_basis_operator_subtract(rb_godot_basis_pointer_to_godot(p_self), rb_godot_basis_pointer_to_godot(p_b));
  VALUE ret = rb_godot_basis_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_operator_multiply_vector (VALUE p_self, VALUE p_b) {
  
  godot_basis value = api->godot_basis_operator_multiply_vector(rb_godot_basis_pointer_to_godot(p_self), rb_godot_basis_pointer_to_godot(p_b));
  VALUE ret = rb_godot_basis_from_godot(value);
  
  return ret;
}
VALUE rb_godot_basis_operator_multiply_scalar (VALUE p_self, VALUE p_b) {
  
  godot_basis value = api->godot_basis_operator_multiply_scalar(rb_godot_basis_pointer_to_godot(p_self), rb_godot_real_to_godot(p_b));
  VALUE ret = rb_godot_basis_from_godot(value);
  
  return ret;
}
VALUE rb_godot_color_get_r (VALUE p_self) {
  
  godot_real value = api->godot_color_get_r(rb_godot_color_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_color_set_r (VALUE p_self, VALUE r) {
  
  api->godot_color_set_r(rb_godot_color_pointer_to_godot(p_self), rb_godot_real_to_godot(r));
  
  return Qnil;
}
VALUE rb_godot_color_get_g (VALUE p_self) {
  
  godot_real value = api->godot_color_get_g(rb_godot_color_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_color_set_g (VALUE p_self, VALUE g) {
  
  api->godot_color_set_g(rb_godot_color_pointer_to_godot(p_self), rb_godot_real_to_godot(g));
  
  return Qnil;
}
VALUE rb_godot_color_get_b (VALUE p_self) {
  
  godot_real value = api->godot_color_get_b(rb_godot_color_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_color_set_b (VALUE p_self, VALUE b) {
  
  api->godot_color_set_b(rb_godot_color_pointer_to_godot(p_self), rb_godot_real_to_godot(b));
  
  return Qnil;
}
VALUE rb_godot_color_get_a (VALUE p_self) {
  
  godot_real value = api->godot_color_get_a(rb_godot_color_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_color_set_a (VALUE p_self, VALUE a) {
  
  api->godot_color_set_a(rb_godot_color_pointer_to_godot(p_self), rb_godot_real_to_godot(a));
  
  return Qnil;
}
VALUE rb_godot_color_get_h (VALUE p_self) {
  
  godot_real value = api->godot_color_get_h(rb_godot_color_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_color_get_s (VALUE p_self) {
  
  godot_real value = api->godot_color_get_s(rb_godot_color_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_color_get_v (VALUE p_self) {
  
  godot_real value = api->godot_color_get_v(rb_godot_color_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_color_as_string (VALUE p_self) {
  
  godot_string value = api->godot_color_as_string(rb_godot_color_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_color_to_rgba32 (VALUE p_self) {
  
  godot_int value = api->godot_color_to_rgba32(rb_godot_color_pointer_to_godot(p_self));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_color_to_argb32 (VALUE p_self) {
  
  godot_int value = api->godot_color_to_argb32(rb_godot_color_pointer_to_godot(p_self));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_color_gray (VALUE p_self) {
  
  godot_real value = api->godot_color_gray(rb_godot_color_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_color_inverted (VALUE p_self) {
  
  godot_color value = api->godot_color_inverted(rb_godot_color_pointer_to_godot(p_self));
  VALUE ret = rb_godot_color_from_godot(value);
  
  return ret;
}
VALUE rb_godot_color_contrasted (VALUE p_self) {
  
  godot_color value = api->godot_color_contrasted(rb_godot_color_pointer_to_godot(p_self));
  VALUE ret = rb_godot_color_from_godot(value);
  
  return ret;
}
VALUE rb_godot_color_linear_interpolate (VALUE p_self, VALUE p_b, VALUE p_t) {
  
  godot_color value = api->godot_color_linear_interpolate(rb_godot_color_pointer_to_godot(p_self), rb_godot_color_pointer_to_godot(p_b), rb_godot_real_to_godot(p_t));
  VALUE ret = rb_godot_color_from_godot(value);
  
  return ret;
}
VALUE rb_godot_color_blend (VALUE p_self, VALUE p_over) {
  
  godot_color value = api->godot_color_blend(rb_godot_color_pointer_to_godot(p_self), rb_godot_color_pointer_to_godot(p_over));
  VALUE ret = rb_godot_color_from_godot(value);
  
  return ret;
}
VALUE rb_godot_color_to_html (VALUE p_self, VALUE p_with_alpha) {
  
  godot_string value = api->godot_color_to_html(rb_godot_color_pointer_to_godot(p_self), rb_godot_bool_to_godot(p_with_alpha));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_color_operator_equal (VALUE p_self, VALUE p_b) {
  
  godot_bool value = api->godot_color_operator_equal(rb_godot_color_pointer_to_godot(p_self), rb_godot_color_pointer_to_godot(p_b));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_color_operator_less (VALUE p_self, VALUE p_b) {
  
  godot_bool value = api->godot_color_operator_less(rb_godot_color_pointer_to_godot(p_self), rb_godot_color_pointer_to_godot(p_b));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_plane_as_string (VALUE p_self) {
  
  godot_string value = api->godot_plane_as_string(rb_godot_plane_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_plane_normalized (VALUE p_self) {
  
  godot_plane value = api->godot_plane_normalized(rb_godot_plane_pointer_to_godot(p_self));
  VALUE ret = rb_godot_plane_from_godot(value);
  
  return ret;
}
VALUE rb_godot_plane_center (VALUE p_self) {
  
  godot_vector3 value = api->godot_plane_center(rb_godot_plane_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_plane_get_any_point (VALUE p_self) {
  
  godot_vector3 value = api->godot_plane_get_any_point(rb_godot_plane_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_plane_is_point_over (VALUE p_self, VALUE p_point) {
  
  godot_bool value = api->godot_plane_is_point_over(rb_godot_plane_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_point));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_plane_distance_to (VALUE p_self, VALUE p_point) {
  
  godot_real value = api->godot_plane_distance_to(rb_godot_plane_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_point));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_plane_has_point (VALUE p_self, VALUE p_point, VALUE p_epsilon) {
  
  godot_bool value = api->godot_plane_has_point(rb_godot_plane_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_point), rb_godot_real_to_godot(p_epsilon));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_plane_project (VALUE p_self, VALUE p_point) {
  
  godot_vector3 value = api->godot_plane_project(rb_godot_plane_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_point));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_plane_intersect_3 (VALUE p_self, VALUE r_dest, VALUE p_b, VALUE p_c) {
  
  godot_bool value = api->godot_plane_intersect_3(rb_godot_plane_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(r_dest), rb_godot_plane_pointer_to_godot(p_b), rb_godot_plane_pointer_to_godot(p_c));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_plane_intersects_ray (VALUE p_self, VALUE r_dest, VALUE p_from, VALUE p_dir) {
  
  godot_bool value = api->godot_plane_intersects_ray(rb_godot_plane_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(r_dest), rb_godot_vector3_pointer_to_godot(p_from), rb_godot_vector3_pointer_to_godot(p_dir));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_plane_intersects_segment (VALUE p_self, VALUE r_dest, VALUE p_begin, VALUE p_end) {
  
  godot_bool value = api->godot_plane_intersects_segment(rb_godot_plane_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(r_dest), rb_godot_vector3_pointer_to_godot(p_begin), rb_godot_vector3_pointer_to_godot(p_end));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_plane_operator_neg (VALUE p_self) {
  
  godot_plane value = api->godot_plane_operator_neg(rb_godot_plane_pointer_to_godot(p_self));
  VALUE ret = rb_godot_plane_from_godot(value);
  
  return ret;
}
VALUE rb_godot_plane_operator_equal (VALUE p_self, VALUE p_b) {
  
  godot_bool value = api->godot_plane_operator_equal(rb_godot_plane_pointer_to_godot(p_self), rb_godot_plane_pointer_to_godot(p_b));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_plane_set_normal (VALUE p_self, VALUE p_normal) {
  
  api->godot_plane_set_normal(rb_godot_plane_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_normal));
  
  return Qnil;
}
VALUE rb_godot_plane_get_normal (VALUE p_self) {
  
  godot_vector3 value = api->godot_plane_get_normal(rb_godot_plane_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_plane_get_d (VALUE p_self) {
  
  godot_real value = api->godot_plane_get_d(rb_godot_plane_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_plane_set_d (VALUE p_self, VALUE p_d) {
  
  api->godot_plane_set_d(rb_godot_plane_pointer_to_godot(p_self), rb_godot_real_to_godot(p_d));
  
  return Qnil;
}
VALUE rb_godot_quat_get_x (VALUE p_self) {
  
  godot_real value = api->godot_quat_get_x(rb_godot_quat_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_set_x (VALUE p_self, VALUE val) {
  
  api->godot_quat_set_x(rb_godot_quat_pointer_to_godot(p_self), rb_godot_real_to_godot(val));
  
  return Qnil;
}
VALUE rb_godot_quat_get_y (VALUE p_self) {
  
  godot_real value = api->godot_quat_get_y(rb_godot_quat_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_set_y (VALUE p_self, VALUE val) {
  
  api->godot_quat_set_y(rb_godot_quat_pointer_to_godot(p_self), rb_godot_real_to_godot(val));
  
  return Qnil;
}
VALUE rb_godot_quat_get_z (VALUE p_self) {
  
  godot_real value = api->godot_quat_get_z(rb_godot_quat_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_set_z (VALUE p_self, VALUE val) {
  
  api->godot_quat_set_z(rb_godot_quat_pointer_to_godot(p_self), rb_godot_real_to_godot(val));
  
  return Qnil;
}
VALUE rb_godot_quat_get_w (VALUE p_self) {
  
  godot_real value = api->godot_quat_get_w(rb_godot_quat_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_set_w (VALUE p_self, VALUE val) {
  
  api->godot_quat_set_w(rb_godot_quat_pointer_to_godot(p_self), rb_godot_real_to_godot(val));
  
  return Qnil;
}
VALUE rb_godot_quat_as_string (VALUE p_self) {
  
  godot_string value = api->godot_quat_as_string(rb_godot_quat_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_length (VALUE p_self) {
  
  godot_real value = api->godot_quat_length(rb_godot_quat_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_length_squared (VALUE p_self) {
  
  godot_real value = api->godot_quat_length_squared(rb_godot_quat_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_normalized (VALUE p_self) {
  
  godot_quat value = api->godot_quat_normalized(rb_godot_quat_pointer_to_godot(p_self));
  VALUE ret = rb_godot_quat_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_is_normalized (VALUE p_self) {
  
  godot_bool value = api->godot_quat_is_normalized(rb_godot_quat_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_inverse (VALUE p_self) {
  
  godot_quat value = api->godot_quat_inverse(rb_godot_quat_pointer_to_godot(p_self));
  VALUE ret = rb_godot_quat_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_dot (VALUE p_self, VALUE p_b) {
  
  godot_real value = api->godot_quat_dot(rb_godot_quat_pointer_to_godot(p_self), rb_godot_quat_pointer_to_godot(p_b));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_xform (VALUE p_self, VALUE p_v) {
  
  godot_vector3 value = api->godot_quat_xform(rb_godot_quat_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_v));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_slerp (VALUE p_self, VALUE p_b, VALUE p_t) {
  
  godot_quat value = api->godot_quat_slerp(rb_godot_quat_pointer_to_godot(p_self), rb_godot_quat_pointer_to_godot(p_b), rb_godot_real_to_godot(p_t));
  VALUE ret = rb_godot_quat_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_slerpni (VALUE p_self, VALUE p_b, VALUE p_t) {
  
  godot_quat value = api->godot_quat_slerpni(rb_godot_quat_pointer_to_godot(p_self), rb_godot_quat_pointer_to_godot(p_b), rb_godot_real_to_godot(p_t));
  VALUE ret = rb_godot_quat_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_cubic_slerp (VALUE p_self, VALUE p_b, VALUE p_pre_a, VALUE p_post_b, VALUE p_t) {
  
  godot_quat value = api->godot_quat_cubic_slerp(rb_godot_quat_pointer_to_godot(p_self), rb_godot_quat_pointer_to_godot(p_b), rb_godot_quat_pointer_to_godot(p_pre_a), rb_godot_quat_pointer_to_godot(p_post_b), rb_godot_real_to_godot(p_t));
  VALUE ret = rb_godot_quat_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_operator_multiply (VALUE p_self, VALUE p_b) {
  
  godot_quat value = api->godot_quat_operator_multiply(rb_godot_quat_pointer_to_godot(p_self), rb_godot_real_to_godot(p_b));
  VALUE ret = rb_godot_quat_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_operator_add (VALUE p_self, VALUE p_b) {
  
  godot_quat value = api->godot_quat_operator_add(rb_godot_quat_pointer_to_godot(p_self), rb_godot_quat_pointer_to_godot(p_b));
  VALUE ret = rb_godot_quat_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_operator_subtract (VALUE p_self, VALUE p_b) {
  
  godot_quat value = api->godot_quat_operator_subtract(rb_godot_quat_pointer_to_godot(p_self), rb_godot_quat_pointer_to_godot(p_b));
  VALUE ret = rb_godot_quat_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_operator_divide (VALUE p_self, VALUE p_b) {
  
  godot_quat value = api->godot_quat_operator_divide(rb_godot_quat_pointer_to_godot(p_self), rb_godot_real_to_godot(p_b));
  VALUE ret = rb_godot_quat_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_operator_equal (VALUE p_self, VALUE p_b) {
  
  godot_bool value = api->godot_quat_operator_equal(rb_godot_quat_pointer_to_godot(p_self), rb_godot_quat_pointer_to_godot(p_b));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_quat_operator_neg (VALUE p_self) {
  
  godot_quat value = api->godot_quat_operator_neg(rb_godot_quat_pointer_to_godot(p_self));
  VALUE ret = rb_godot_quat_from_godot(value);
  
  return ret;
}
VALUE rb_godot_rect2_as_string (VALUE p_self) {
  
  godot_string value = api->godot_rect2_as_string(rb_godot_rect2_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_rect2_get_area (VALUE p_self) {
  
  godot_real value = api->godot_rect2_get_area(rb_godot_rect2_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_rect2_intersects (VALUE p_self, VALUE p_b) {
  
  godot_bool value = api->godot_rect2_intersects(rb_godot_rect2_pointer_to_godot(p_self), rb_godot_rect2_pointer_to_godot(p_b));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_rect2_encloses (VALUE p_self, VALUE p_b) {
  
  godot_bool value = api->godot_rect2_encloses(rb_godot_rect2_pointer_to_godot(p_self), rb_godot_rect2_pointer_to_godot(p_b));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_rect2_has_no_area (VALUE p_self) {
  
  godot_bool value = api->godot_rect2_has_no_area(rb_godot_rect2_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_rect2_clip (VALUE p_self, VALUE p_b) {
  
  godot_rect2 value = api->godot_rect2_clip(rb_godot_rect2_pointer_to_godot(p_self), rb_godot_rect2_pointer_to_godot(p_b));
  VALUE ret = rb_godot_rect2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_rect2_merge (VALUE p_self, VALUE p_b) {
  
  godot_rect2 value = api->godot_rect2_merge(rb_godot_rect2_pointer_to_godot(p_self), rb_godot_rect2_pointer_to_godot(p_b));
  VALUE ret = rb_godot_rect2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_rect2_has_point (VALUE p_self, VALUE p_point) {
  
  godot_bool value = api->godot_rect2_has_point(rb_godot_rect2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_point));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_rect2_grow (VALUE p_self, VALUE p_by) {
  
  godot_rect2 value = api->godot_rect2_grow(rb_godot_rect2_pointer_to_godot(p_self), rb_godot_real_to_godot(p_by));
  VALUE ret = rb_godot_rect2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_rect2_expand (VALUE p_self, VALUE p_to) {
  
  godot_rect2 value = api->godot_rect2_expand(rb_godot_rect2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_to));
  VALUE ret = rb_godot_rect2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_rect2_operator_equal (VALUE p_self, VALUE p_b) {
  
  godot_bool value = api->godot_rect2_operator_equal(rb_godot_rect2_pointer_to_godot(p_self), rb_godot_rect2_pointer_to_godot(p_b));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_rect2_get_position (VALUE p_self) {
  
  godot_vector2 value = api->godot_rect2_get_position(rb_godot_rect2_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_rect2_get_size (VALUE p_self) {
  
  godot_vector2 value = api->godot_rect2_get_size(rb_godot_rect2_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_rect2_set_position (VALUE p_self, VALUE p_pos) {
  
  api->godot_rect2_set_position(rb_godot_rect2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_pos));
  
  return Qnil;
}
VALUE rb_godot_rect2_set_size (VALUE p_self, VALUE p_size) {
  
  api->godot_rect2_set_size(rb_godot_rect2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_size));
  
  return Qnil;
}
VALUE rb_godot_transform_get_basis (VALUE p_self) {
  
  godot_basis value = api->godot_transform_get_basis(rb_godot_transform_pointer_to_godot(p_self));
  VALUE ret = rb_godot_basis_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform_set_basis (VALUE p_self, VALUE p_v) {
  
  api->godot_transform_set_basis(rb_godot_transform_pointer_to_godot(p_self), rb_godot_basis_pointer_to_godot(p_v));
  
  return Qnil;
}
VALUE rb_godot_transform_get_origin (VALUE p_self) {
  
  godot_vector3 value = api->godot_transform_get_origin(rb_godot_transform_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform_set_origin (VALUE p_self, VALUE p_v) {
  
  api->godot_transform_set_origin(rb_godot_transform_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_v));
  
  return Qnil;
}
VALUE rb_godot_transform_as_string (VALUE p_self) {
  
  godot_string value = api->godot_transform_as_string(rb_godot_transform_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform_inverse (VALUE p_self) {
  
  godot_transform value = api->godot_transform_inverse(rb_godot_transform_pointer_to_godot(p_self));
  VALUE ret = rb_godot_transform_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform_affine_inverse (VALUE p_self) {
  
  godot_transform value = api->godot_transform_affine_inverse(rb_godot_transform_pointer_to_godot(p_self));
  VALUE ret = rb_godot_transform_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform_orthonormalized (VALUE p_self) {
  
  godot_transform value = api->godot_transform_orthonormalized(rb_godot_transform_pointer_to_godot(p_self));
  VALUE ret = rb_godot_transform_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform_rotated (VALUE p_self, VALUE p_axis, VALUE p_phi) {
  
  godot_transform value = api->godot_transform_rotated(rb_godot_transform_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_axis), rb_godot_real_to_godot(p_phi));
  VALUE ret = rb_godot_transform_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform_scaled (VALUE p_self, VALUE p_scale) {
  
  godot_transform value = api->godot_transform_scaled(rb_godot_transform_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_scale));
  VALUE ret = rb_godot_transform_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform_translated (VALUE p_self, VALUE p_ofs) {
  
  godot_transform value = api->godot_transform_translated(rb_godot_transform_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_ofs));
  VALUE ret = rb_godot_transform_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform_looking_at (VALUE p_self, VALUE p_target, VALUE p_up) {
  
  godot_transform value = api->godot_transform_looking_at(rb_godot_transform_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_target), rb_godot_vector3_pointer_to_godot(p_up));
  VALUE ret = rb_godot_transform_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform_xform_plane (VALUE p_self, VALUE p_v) {
  
  godot_plane value = api->godot_transform_xform_plane(rb_godot_transform_pointer_to_godot(p_self), rb_godot_plane_pointer_to_godot(p_v));
  VALUE ret = rb_godot_plane_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform_xform_inv_plane (VALUE p_self, VALUE p_v) {
  
  godot_plane value = api->godot_transform_xform_inv_plane(rb_godot_transform_pointer_to_godot(p_self), rb_godot_plane_pointer_to_godot(p_v));
  VALUE ret = rb_godot_plane_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform_operator_equal (VALUE p_self, VALUE p_b) {
  
  godot_bool value = api->godot_transform_operator_equal(rb_godot_transform_pointer_to_godot(p_self), rb_godot_transform_pointer_to_godot(p_b));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform_operator_multiply (VALUE p_self, VALUE p_b) {
  
  godot_transform value = api->godot_transform_operator_multiply(rb_godot_transform_pointer_to_godot(p_self), rb_godot_transform_pointer_to_godot(p_b));
  VALUE ret = rb_godot_transform_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform_xform_vector3 (VALUE p_self, VALUE p_v) {
  
  godot_vector3 value = api->godot_transform_xform_vector3(rb_godot_transform_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_v));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform_xform_inv_vector3 (VALUE p_self, VALUE p_v) {
  
  godot_vector3 value = api->godot_transform_xform_inv_vector3(rb_godot_transform_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_v));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform_xform_aabb (VALUE p_self, VALUE p_v) {
  
  godot_aabb value = api->godot_transform_xform_aabb(rb_godot_transform_pointer_to_godot(p_self), rb_godot_aabb_pointer_to_godot(p_v));
  VALUE ret = rb_godot_aabb_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform_xform_inv_aabb (VALUE p_self, VALUE p_v) {
  
  godot_aabb value = api->godot_transform_xform_inv_aabb(rb_godot_transform_pointer_to_godot(p_self), rb_godot_aabb_pointer_to_godot(p_v));
  VALUE ret = rb_godot_aabb_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform2d_as_string (VALUE p_self) {
  
  godot_string value = api->godot_transform2d_as_string(rb_godot_transform2d_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform2d_inverse (VALUE p_self) {
  
  godot_transform2d value = api->godot_transform2d_inverse(rb_godot_transform2d_pointer_to_godot(p_self));
  VALUE ret = rb_godot_transform2d_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform2d_affine_inverse (VALUE p_self) {
  
  godot_transform2d value = api->godot_transform2d_affine_inverse(rb_godot_transform2d_pointer_to_godot(p_self));
  VALUE ret = rb_godot_transform2d_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform2d_get_rotation (VALUE p_self) {
  
  godot_real value = api->godot_transform2d_get_rotation(rb_godot_transform2d_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform2d_get_origin (VALUE p_self) {
  
  godot_vector2 value = api->godot_transform2d_get_origin(rb_godot_transform2d_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform2d_get_scale (VALUE p_self) {
  
  godot_vector2 value = api->godot_transform2d_get_scale(rb_godot_transform2d_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform2d_orthonormalized (VALUE p_self) {
  
  godot_transform2d value = api->godot_transform2d_orthonormalized(rb_godot_transform2d_pointer_to_godot(p_self));
  VALUE ret = rb_godot_transform2d_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform2d_rotated (VALUE p_self, VALUE p_phi) {
  
  godot_transform2d value = api->godot_transform2d_rotated(rb_godot_transform2d_pointer_to_godot(p_self), rb_godot_real_to_godot(p_phi));
  VALUE ret = rb_godot_transform2d_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform2d_scaled (VALUE p_self, VALUE p_scale) {
  
  godot_transform2d value = api->godot_transform2d_scaled(rb_godot_transform2d_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_scale));
  VALUE ret = rb_godot_transform2d_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform2d_translated (VALUE p_self, VALUE p_offset) {
  
  godot_transform2d value = api->godot_transform2d_translated(rb_godot_transform2d_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_offset));
  VALUE ret = rb_godot_transform2d_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform2d_xform_vector2 (VALUE p_self, VALUE p_v) {
  
  godot_vector2 value = api->godot_transform2d_xform_vector2(rb_godot_transform2d_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_v));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform2d_xform_inv_vector2 (VALUE p_self, VALUE p_v) {
  
  godot_vector2 value = api->godot_transform2d_xform_inv_vector2(rb_godot_transform2d_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_v));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform2d_basis_xform_vector2 (VALUE p_self, VALUE p_v) {
  
  godot_vector2 value = api->godot_transform2d_basis_xform_vector2(rb_godot_transform2d_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_v));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform2d_basis_xform_inv_vector2 (VALUE p_self, VALUE p_v) {
  
  godot_vector2 value = api->godot_transform2d_basis_xform_inv_vector2(rb_godot_transform2d_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_v));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform2d_interpolate_with (VALUE p_self, VALUE p_m, VALUE p_c) {
  
  godot_transform2d value = api->godot_transform2d_interpolate_with(rb_godot_transform2d_pointer_to_godot(p_self), rb_godot_transform2d_pointer_to_godot(p_m), rb_godot_real_to_godot(p_c));
  VALUE ret = rb_godot_transform2d_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform2d_operator_equal (VALUE p_self, VALUE p_b) {
  
  godot_bool value = api->godot_transform2d_operator_equal(rb_godot_transform2d_pointer_to_godot(p_self), rb_godot_transform2d_pointer_to_godot(p_b));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform2d_operator_multiply (VALUE p_self, VALUE p_b) {
  
  godot_transform2d value = api->godot_transform2d_operator_multiply(rb_godot_transform2d_pointer_to_godot(p_self), rb_godot_transform2d_pointer_to_godot(p_b));
  VALUE ret = rb_godot_transform2d_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform2d_xform_rect2 (VALUE p_self, VALUE p_v) {
  
  godot_rect2 value = api->godot_transform2d_xform_rect2(rb_godot_transform2d_pointer_to_godot(p_self), rb_godot_rect2_pointer_to_godot(p_v));
  VALUE ret = rb_godot_rect2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_transform2d_xform_inv_rect2 (VALUE p_self, VALUE p_v) {
  
  godot_rect2 value = api->godot_transform2d_xform_inv_rect2(rb_godot_transform2d_pointer_to_godot(p_self), rb_godot_rect2_pointer_to_godot(p_v));
  VALUE ret = rb_godot_rect2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_as_string (VALUE p_self) {
  
  godot_string value = api->godot_vector2_as_string(rb_godot_vector2_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_normalized (VALUE p_self) {
  
  godot_vector2 value = api->godot_vector2_normalized(rb_godot_vector2_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_length (VALUE p_self) {
  
  godot_real value = api->godot_vector2_length(rb_godot_vector2_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_angle (VALUE p_self) {
  
  godot_real value = api->godot_vector2_angle(rb_godot_vector2_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_length_squared (VALUE p_self) {
  
  godot_real value = api->godot_vector2_length_squared(rb_godot_vector2_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_is_normalized (VALUE p_self) {
  
  godot_bool value = api->godot_vector2_is_normalized(rb_godot_vector2_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_distance_to (VALUE p_self, VALUE p_to) {
  
  godot_real value = api->godot_vector2_distance_to(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_to));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_distance_squared_to (VALUE p_self, VALUE p_to) {
  
  godot_real value = api->godot_vector2_distance_squared_to(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_to));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_angle_to (VALUE p_self, VALUE p_to) {
  
  godot_real value = api->godot_vector2_angle_to(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_to));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_angle_to_point (VALUE p_self, VALUE p_to) {
  
  godot_real value = api->godot_vector2_angle_to_point(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_to));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_linear_interpolate (VALUE p_self, VALUE p_b, VALUE p_t) {
  
  godot_vector2 value = api->godot_vector2_linear_interpolate(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_b), rb_godot_real_to_godot(p_t));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_cubic_interpolate (VALUE p_self, VALUE p_b, VALUE p_pre_a, VALUE p_post_b, VALUE p_t) {
  
  godot_vector2 value = api->godot_vector2_cubic_interpolate(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_b), rb_godot_vector2_pointer_to_godot(p_pre_a), rb_godot_vector2_pointer_to_godot(p_post_b), rb_godot_real_to_godot(p_t));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_rotated (VALUE p_self, VALUE p_phi) {
  
  godot_vector2 value = api->godot_vector2_rotated(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_real_to_godot(p_phi));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_tangent (VALUE p_self) {
  
  godot_vector2 value = api->godot_vector2_tangent(rb_godot_vector2_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_floor (VALUE p_self) {
  
  godot_vector2 value = api->godot_vector2_floor(rb_godot_vector2_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_snapped (VALUE p_self, VALUE p_by) {
  
  godot_vector2 value = api->godot_vector2_snapped(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_by));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_aspect (VALUE p_self) {
  
  godot_real value = api->godot_vector2_aspect(rb_godot_vector2_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_dot (VALUE p_self, VALUE p_with) {
  
  godot_real value = api->godot_vector2_dot(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_with));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_slide (VALUE p_self, VALUE p_n) {
  
  godot_vector2 value = api->godot_vector2_slide(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_n));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_bounce (VALUE p_self, VALUE p_n) {
  
  godot_vector2 value = api->godot_vector2_bounce(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_n));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_reflect (VALUE p_self, VALUE p_n) {
  
  godot_vector2 value = api->godot_vector2_reflect(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_n));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_abs (VALUE p_self) {
  
  godot_vector2 value = api->godot_vector2_abs(rb_godot_vector2_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_clamped (VALUE p_self, VALUE p_length) {
  
  godot_vector2 value = api->godot_vector2_clamped(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_real_to_godot(p_length));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_operator_add (VALUE p_self, VALUE p_b) {
  
  godot_vector2 value = api->godot_vector2_operator_add(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_b));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_operator_subtract (VALUE p_self, VALUE p_b) {
  
  godot_vector2 value = api->godot_vector2_operator_subtract(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_b));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_operator_multiply_vector (VALUE p_self, VALUE p_b) {
  
  godot_vector2 value = api->godot_vector2_operator_multiply_vector(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_b));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_operator_multiply_scalar (VALUE p_self, VALUE p_b) {
  
  godot_vector2 value = api->godot_vector2_operator_multiply_scalar(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_real_to_godot(p_b));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_operator_divide_vector (VALUE p_self, VALUE p_b) {
  
  godot_vector2 value = api->godot_vector2_operator_divide_vector(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_b));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_operator_divide_scalar (VALUE p_self, VALUE p_b) {
  
  godot_vector2 value = api->godot_vector2_operator_divide_scalar(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_real_to_godot(p_b));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_operator_equal (VALUE p_self, VALUE p_b) {
  
  godot_bool value = api->godot_vector2_operator_equal(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_b));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_operator_less (VALUE p_self, VALUE p_b) {
  
  godot_bool value = api->godot_vector2_operator_less(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_vector2_pointer_to_godot(p_b));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_operator_neg (VALUE p_self) {
  
  godot_vector2 value = api->godot_vector2_operator_neg(rb_godot_vector2_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector2_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_set_x (VALUE p_self, VALUE p_x) {
  
  api->godot_vector2_set_x(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_real_to_godot(p_x));
  
  return Qnil;
}
VALUE rb_godot_vector2_set_y (VALUE p_self, VALUE p_y) {
  
  api->godot_vector2_set_y(rb_godot_vector2_pointer_to_godot(p_self), rb_godot_real_to_godot(p_y));
  
  return Qnil;
}
VALUE rb_godot_vector2_get_x (VALUE p_self) {
  
  godot_real value = api->godot_vector2_get_x(rb_godot_vector2_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector2_get_y (VALUE p_self) {
  
  godot_real value = api->godot_vector2_get_y(rb_godot_vector2_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_as_string (VALUE p_self) {
  
  godot_string value = api->godot_vector3_as_string(rb_godot_vector3_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_min_axis (VALUE p_self) {
  
  godot_int value = api->godot_vector3_min_axis(rb_godot_vector3_pointer_to_godot(p_self));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_max_axis (VALUE p_self) {
  
  godot_int value = api->godot_vector3_max_axis(rb_godot_vector3_pointer_to_godot(p_self));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_length (VALUE p_self) {
  
  godot_real value = api->godot_vector3_length(rb_godot_vector3_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_length_squared (VALUE p_self) {
  
  godot_real value = api->godot_vector3_length_squared(rb_godot_vector3_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_is_normalized (VALUE p_self) {
  
  godot_bool value = api->godot_vector3_is_normalized(rb_godot_vector3_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_normalized (VALUE p_self) {
  
  godot_vector3 value = api->godot_vector3_normalized(rb_godot_vector3_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_inverse (VALUE p_self) {
  
  godot_vector3 value = api->godot_vector3_inverse(rb_godot_vector3_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_snapped (VALUE p_self, VALUE p_by) {
  
  godot_vector3 value = api->godot_vector3_snapped(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_by));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_rotated (VALUE p_self, VALUE p_axis, VALUE p_phi) {
  
  godot_vector3 value = api->godot_vector3_rotated(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_axis), rb_godot_real_to_godot(p_phi));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_linear_interpolate (VALUE p_self, VALUE p_b, VALUE p_t) {
  
  godot_vector3 value = api->godot_vector3_linear_interpolate(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_b), rb_godot_real_to_godot(p_t));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_cubic_interpolate (VALUE p_self, VALUE p_b, VALUE p_pre_a, VALUE p_post_b, VALUE p_t) {
  
  godot_vector3 value = api->godot_vector3_cubic_interpolate(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_b), rb_godot_vector3_pointer_to_godot(p_pre_a), rb_godot_vector3_pointer_to_godot(p_post_b), rb_godot_real_to_godot(p_t));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_dot (VALUE p_self, VALUE p_b) {
  
  godot_real value = api->godot_vector3_dot(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_b));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_cross (VALUE p_self, VALUE p_b) {
  
  godot_vector3 value = api->godot_vector3_cross(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_b));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_outer (VALUE p_self, VALUE p_b) {
  
  godot_basis value = api->godot_vector3_outer(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_b));
  VALUE ret = rb_godot_basis_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_to_diagonal_matrix (VALUE p_self) {
  
  godot_basis value = api->godot_vector3_to_diagonal_matrix(rb_godot_vector3_pointer_to_godot(p_self));
  VALUE ret = rb_godot_basis_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_abs (VALUE p_self) {
  
  godot_vector3 value = api->godot_vector3_abs(rb_godot_vector3_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_floor (VALUE p_self) {
  
  godot_vector3 value = api->godot_vector3_floor(rb_godot_vector3_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_ceil (VALUE p_self) {
  
  godot_vector3 value = api->godot_vector3_ceil(rb_godot_vector3_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_distance_to (VALUE p_self, VALUE p_b) {
  
  godot_real value = api->godot_vector3_distance_to(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_b));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_distance_squared_to (VALUE p_self, VALUE p_b) {
  
  godot_real value = api->godot_vector3_distance_squared_to(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_b));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_angle_to (VALUE p_self, VALUE p_to) {
  
  godot_real value = api->godot_vector3_angle_to(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_to));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_slide (VALUE p_self, VALUE p_n) {
  
  godot_vector3 value = api->godot_vector3_slide(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_n));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_bounce (VALUE p_self, VALUE p_n) {
  
  godot_vector3 value = api->godot_vector3_bounce(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_n));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_reflect (VALUE p_self, VALUE p_n) {
  
  godot_vector3 value = api->godot_vector3_reflect(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_n));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_operator_add (VALUE p_self, VALUE p_b) {
  
  godot_vector3 value = api->godot_vector3_operator_add(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_b));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_operator_subtract (VALUE p_self, VALUE p_b) {
  
  godot_vector3 value = api->godot_vector3_operator_subtract(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_b));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_operator_multiply_vector (VALUE p_self, VALUE p_b) {
  
  godot_vector3 value = api->godot_vector3_operator_multiply_vector(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_b));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_operator_multiply_scalar (VALUE p_self, VALUE p_b) {
  
  godot_vector3 value = api->godot_vector3_operator_multiply_scalar(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_real_to_godot(p_b));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_operator_divide_vector (VALUE p_self, VALUE p_b) {
  
  godot_vector3 value = api->godot_vector3_operator_divide_vector(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_b));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_operator_divide_scalar (VALUE p_self, VALUE p_b) {
  
  godot_vector3 value = api->godot_vector3_operator_divide_scalar(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_real_to_godot(p_b));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_operator_equal (VALUE p_self, VALUE p_b) {
  
  godot_bool value = api->godot_vector3_operator_equal(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_b));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_operator_less (VALUE p_self, VALUE p_b) {
  
  godot_bool value = api->godot_vector3_operator_less(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_pointer_to_godot(p_b));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_operator_neg (VALUE p_self) {
  
  godot_vector3 value = api->godot_vector3_operator_neg(rb_godot_vector3_pointer_to_godot(p_self));
  VALUE ret = rb_godot_vector3_from_godot(value);
  
  return ret;
}
VALUE rb_godot_vector3_set_axis (VALUE p_self, VALUE p_axis, VALUE p_val) {
  
  api->godot_vector3_set_axis(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_axis_to_godot(p_axis), rb_godot_real_to_godot(p_val));
  
  return Qnil;
}
VALUE rb_godot_vector3_get_axis (VALUE p_self, VALUE p_axis) {
  
  godot_real value = api->godot_vector3_get_axis(rb_godot_vector3_pointer_to_godot(p_self), rb_godot_vector3_axis_to_godot(p_axis));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_array_set (VALUE p_self, VALUE p_idx, VALUE p_value) {
  godot_variant p_value_v = rb_godot_variant_to_godot(p_value);
  api->godot_array_set(rb_godot_array_pointer_to_godot(p_self), rb_godot_int_to_godot(p_idx), &p_value_v);
  api->godot_variant_destroy(&p_value_v);
  return Qnil;
}
VALUE rb_godot_array_get (VALUE p_self, VALUE p_idx) {
  
  godot_variant value = api->godot_array_get(rb_godot_array_pointer_to_godot(p_self), rb_godot_int_to_godot(p_idx));
  VALUE ret = rb_godot_variant_from_godot(value);
  
  return ret;
}
VALUE rb_godot_array_operator_index (VALUE p_self, VALUE p_idx) {
  
  godot_variant * value = api->godot_array_operator_index(rb_godot_array_pointer_to_godot(p_self), rb_godot_int_to_godot(p_idx));
  VALUE ret = rb_godot_variant_pointer_from_godot(value);
  
  return ret;
}
VALUE rb_godot_array_operator_index_const (VALUE p_self, VALUE p_idx) {
  
  godot_variant * value = api->godot_array_operator_index_const(rb_godot_array_pointer_to_godot(p_self), rb_godot_int_to_godot(p_idx));
  VALUE ret = rb_godot_variant_pointer_from_godot(value);
  
  return ret;
}
VALUE rb_godot_array_append (VALUE p_self, VALUE p_value) {
  godot_variant p_value_v = rb_godot_variant_to_godot(p_value);
  api->godot_array_append(rb_godot_array_pointer_to_godot(p_self), &p_value_v);
  api->godot_variant_destroy(&p_value_v);
  return Qnil;
}
VALUE rb_godot_array_clear (VALUE p_self) {
  
  api->godot_array_clear(rb_godot_array_pointer_to_godot(p_self));
  
  return Qnil;
}
VALUE rb_godot_array_count (VALUE p_self, VALUE p_value) {
  godot_variant p_value_v = rb_godot_variant_to_godot(p_value);
  godot_int value = api->godot_array_count(rb_godot_array_pointer_to_godot(p_self), &p_value_v);
  VALUE ret = rb_godot_int_from_godot(value);
  api->godot_variant_destroy(&p_value_v);
  return ret;
}
VALUE rb_godot_array_empty (VALUE p_self) {
  
  godot_bool value = api->godot_array_empty(rb_godot_array_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_array_erase (VALUE p_self, VALUE p_value) {
  godot_variant p_value_v = rb_godot_variant_to_godot(p_value);
  api->godot_array_erase(rb_godot_array_pointer_to_godot(p_self), &p_value_v);
  api->godot_variant_destroy(&p_value_v);
  return Qnil;
}
VALUE rb_godot_array_front (VALUE p_self) {
  
  godot_variant value = api->godot_array_front(rb_godot_array_pointer_to_godot(p_self));
  VALUE ret = rb_godot_variant_from_godot(value);
  
  return ret;
}
VALUE rb_godot_array_back (VALUE p_self) {
  
  godot_variant value = api->godot_array_back(rb_godot_array_pointer_to_godot(p_self));
  VALUE ret = rb_godot_variant_from_godot(value);
  
  return ret;
}
VALUE rb_godot_array_find (VALUE p_self, VALUE p_what, VALUE p_from) {
  godot_variant p_what_v = rb_godot_variant_to_godot(p_what);
  godot_int value = api->godot_array_find(rb_godot_array_pointer_to_godot(p_self), &p_what_v, rb_godot_int_to_godot(p_from));
  VALUE ret = rb_godot_int_from_godot(value);
  api->godot_variant_destroy(&p_what_v);
  return ret;
}
VALUE rb_godot_array_find_last (VALUE p_self, VALUE p_what) {
  godot_variant p_what_v = rb_godot_variant_to_godot(p_what);
  godot_int value = api->godot_array_find_last(rb_godot_array_pointer_to_godot(p_self), &p_what_v);
  VALUE ret = rb_godot_int_from_godot(value);
  api->godot_variant_destroy(&p_what_v);
  return ret;
}
VALUE rb_godot_array_has (VALUE p_self, VALUE p_value) {
  godot_variant p_value_v = rb_godot_variant_to_godot(p_value);
  godot_bool value = api->godot_array_has(rb_godot_array_pointer_to_godot(p_self), &p_value_v);
  VALUE ret = rb_godot_bool_from_godot(value);
  api->godot_variant_destroy(&p_value_v);
  return ret;
}
VALUE rb_godot_array_insert (VALUE p_self, VALUE p_pos, VALUE p_value) {
  godot_variant p_value_v = rb_godot_variant_to_godot(p_value);
  api->godot_array_insert(rb_godot_array_pointer_to_godot(p_self), rb_godot_int_to_godot(p_pos), &p_value_v);
  api->godot_variant_destroy(&p_value_v);
  return Qnil;
}
VALUE rb_godot_array_invert (VALUE p_self) {
  
  api->godot_array_invert(rb_godot_array_pointer_to_godot(p_self));
  
  return Qnil;
}
VALUE rb_godot_array_pop_back (VALUE p_self) {
  
  godot_variant value = api->godot_array_pop_back(rb_godot_array_pointer_to_godot(p_self));
  VALUE ret = rb_godot_variant_from_godot(value);
  
  return ret;
}
VALUE rb_godot_array_pop_front (VALUE p_self) {
  
  godot_variant value = api->godot_array_pop_front(rb_godot_array_pointer_to_godot(p_self));
  VALUE ret = rb_godot_variant_from_godot(value);
  
  return ret;
}
VALUE rb_godot_array_push_back (VALUE p_self, VALUE p_value) {
  godot_variant p_value_v = rb_godot_variant_to_godot(p_value);
  api->godot_array_push_back(rb_godot_array_pointer_to_godot(p_self), &p_value_v);
  api->godot_variant_destroy(&p_value_v);
  return Qnil;
}
VALUE rb_godot_array_push_front (VALUE p_self, VALUE p_value) {
  godot_variant p_value_v = rb_godot_variant_to_godot(p_value);
  api->godot_array_push_front(rb_godot_array_pointer_to_godot(p_self), &p_value_v);
  api->godot_variant_destroy(&p_value_v);
  return Qnil;
}
VALUE rb_godot_array_remove (VALUE p_self, VALUE p_idx) {
  
  api->godot_array_remove(rb_godot_array_pointer_to_godot(p_self), rb_godot_int_to_godot(p_idx));
  
  return Qnil;
}
VALUE rb_godot_array_resize (VALUE p_self, VALUE p_size) {
  
  api->godot_array_resize(rb_godot_array_pointer_to_godot(p_self), rb_godot_int_to_godot(p_size));
  
  return Qnil;
}
VALUE rb_godot_array_rfind (VALUE p_self, VALUE p_what, VALUE p_from) {
  godot_variant p_what_v = rb_godot_variant_to_godot(p_what);
  godot_int value = api->godot_array_rfind(rb_godot_array_pointer_to_godot(p_self), &p_what_v, rb_godot_int_to_godot(p_from));
  VALUE ret = rb_godot_int_from_godot(value);
  api->godot_variant_destroy(&p_what_v);
  return ret;
}
VALUE rb_godot_array_size (VALUE p_self) {
  
  godot_int value = api->godot_array_size(rb_godot_array_pointer_to_godot(p_self));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_array_sort (VALUE p_self) {
  
  api->godot_array_sort(rb_godot_array_pointer_to_godot(p_self));
  
  return Qnil;
}
VALUE rb_godot_array_bsearch (VALUE p_self, VALUE p_value, VALUE p_before) {
  godot_variant p_value_v = rb_godot_variant_to_godot(p_value);
  godot_int value = api->godot_array_bsearch(rb_godot_array_pointer_to_godot(p_self), &p_value_v, rb_godot_bool_to_godot(p_before));
  VALUE ret = rb_godot_int_from_godot(value);
  api->godot_variant_destroy(&p_value_v);
  return ret;
}
VALUE rb_godot_array_destroy (VALUE p_self) {
  
  api->godot_array_destroy(rb_godot_array_pointer_to_godot(p_self));
  
  return Qnil;
}
VALUE rb_godot_array_to_a(VALUE self) {
  godot_array *ary = rb_godot_array_pointer_to_godot(self);
  int size = api->godot_array_size(ary);

  VALUE ruby_ary = rb_ary_new();

  for (int i=0; i < size; ++i) {
    godot_variant var = api->godot_array_get(ary, i);
    rb_ary_push(ruby_ary, rb_godot_variant_from_godot(var));
    api->godot_variant_destroy(&var);
  }

  return ruby_ary;
}
VALUE rb_godot_dictionary_destroy (VALUE p_self) {
  
  api->godot_dictionary_destroy(rb_godot_dictionary_pointer_to_godot(p_self));
  
  return Qnil;
}
VALUE rb_godot_dictionary_size (VALUE p_self) {
  
  godot_int value = api->godot_dictionary_size(rb_godot_dictionary_pointer_to_godot(p_self));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_dictionary_empty (VALUE p_self) {
  
  godot_bool value = api->godot_dictionary_empty(rb_godot_dictionary_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_dictionary_clear (VALUE p_self) {
  
  api->godot_dictionary_clear(rb_godot_dictionary_pointer_to_godot(p_self));
  
  return Qnil;
}
VALUE rb_godot_dictionary_has (VALUE p_self, VALUE p_key) {
  godot_variant p_key_v = rb_godot_variant_to_godot(p_key);
  godot_bool value = api->godot_dictionary_has(rb_godot_dictionary_pointer_to_godot(p_self), &p_key_v);
  VALUE ret = rb_godot_bool_from_godot(value);
  api->godot_variant_destroy(&p_key_v);
  return ret;
}
VALUE rb_godot_dictionary_has_all (VALUE p_self, VALUE p_keys) {
  
  godot_bool value = api->godot_dictionary_has_all(rb_godot_dictionary_pointer_to_godot(p_self), rb_godot_array_pointer_to_godot(p_keys));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_dictionary_erase (VALUE p_self, VALUE p_key) {
  godot_variant p_key_v = rb_godot_variant_to_godot(p_key);
  api->godot_dictionary_erase(rb_godot_dictionary_pointer_to_godot(p_self), &p_key_v);
  api->godot_variant_destroy(&p_key_v);
  return Qnil;
}
VALUE rb_godot_dictionary_keys (VALUE p_self) {
  
  godot_array value = api->godot_dictionary_keys(rb_godot_dictionary_pointer_to_godot(p_self));
  VALUE ret = rb_godot_array_from_godot(value);
  
  return ret;
}
VALUE rb_godot_dictionary_values (VALUE p_self) {
  
  godot_array value = api->godot_dictionary_values(rb_godot_dictionary_pointer_to_godot(p_self));
  VALUE ret = rb_godot_array_from_godot(value);
  
  return ret;
}
VALUE rb_godot_dictionary_get (VALUE p_self, VALUE p_key) {
  godot_variant p_key_v = rb_godot_variant_to_godot(p_key);
  godot_variant value = api->godot_dictionary_get(rb_godot_dictionary_pointer_to_godot(p_self), &p_key_v);
  VALUE ret = rb_godot_variant_from_godot(value);
  api->godot_variant_destroy(&p_key_v);
  return ret;
}
VALUE rb_godot_dictionary_set (VALUE p_self, VALUE p_key, VALUE p_value) {
  godot_variant p_key_v = rb_godot_variant_to_godot(p_key);
godot_variant p_value_v = rb_godot_variant_to_godot(p_value);
  api->godot_dictionary_set(rb_godot_dictionary_pointer_to_godot(p_self), &p_key_v, &p_value_v);
  api->godot_variant_destroy(&p_key_v);
api->godot_variant_destroy(&p_value_v);
  return Qnil;
}
VALUE rb_godot_dictionary_operator_index (VALUE p_self, VALUE p_key) {
  godot_variant p_key_v = rb_godot_variant_to_godot(p_key);
  godot_variant * value = api->godot_dictionary_operator_index(rb_godot_dictionary_pointer_to_godot(p_self), &p_key_v);
  VALUE ret = rb_godot_variant_pointer_from_godot(value);
  api->godot_variant_destroy(&p_key_v);
  return ret;
}
VALUE rb_godot_dictionary_operator_index_const (VALUE p_self, VALUE p_key) {
  godot_variant p_key_v = rb_godot_variant_to_godot(p_key);
  godot_variant * value = api->godot_dictionary_operator_index_const(rb_godot_dictionary_pointer_to_godot(p_self), &p_key_v);
  VALUE ret = rb_godot_variant_pointer_from_godot(value);
  api->godot_variant_destroy(&p_key_v);
  return ret;
}
VALUE rb_godot_dictionary_next (VALUE p_self, VALUE p_key) {
  godot_variant p_key_v = rb_godot_variant_to_godot(p_key);
  godot_variant * value = api->godot_dictionary_next(rb_godot_dictionary_pointer_to_godot(p_self), &p_key_v);
  VALUE ret = rb_godot_variant_pointer_from_godot(value);
  api->godot_variant_destroy(&p_key_v);
  return ret;
}
VALUE rb_godot_dictionary_operator_equal (VALUE p_self, VALUE p_b) {
  
  godot_bool value = api->godot_dictionary_operator_equal(rb_godot_dictionary_pointer_to_godot(p_self), rb_godot_dictionary_pointer_to_godot(p_b));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_dictionary_to_json (VALUE p_self) {
  
  godot_string value = api->godot_dictionary_to_json(rb_godot_dictionary_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_dictionary_to_h(VALUE self) {
  godot_dictionary *dict = rb_godot_dictionary_pointer_to_godot(self);

  godot_array keys = api->godot_dictionary_keys(dict);
  godot_array values = api->godot_dictionary_values(dict);

  VALUE r_keys = rb_godot_array_pointer_from_godot(&keys);
  VALUE r_values = rb_godot_array_pointer_from_godot(&values);
  VALUE r_keys_a = rb_funcall(r_keys, rb_intern("to_a"), 0);
  VALUE r_values_a = rb_funcall(r_values, rb_intern("to_a"), 0);
  VALUE zip = rb_funcall(r_keys_a, rb_intern("zip"), 1, r_values_a);

  api->godot_array_destroy(&keys);
  api->godot_array_destroy(&values);
  return rb_funcall(zip, rb_intern("to_h"), 0);
}
VALUE rb_godot_node_path_destroy (VALUE p_self) {
  
  api->godot_node_path_destroy(rb_godot_node_path_pointer_to_godot(p_self));
  
  return Qnil;
}
VALUE rb_godot_node_path_as_string (VALUE p_self) {
  
  godot_string value = api->godot_node_path_as_string(rb_godot_node_path_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_node_path_is_absolute (VALUE p_self) {
  
  godot_bool value = api->godot_node_path_is_absolute(rb_godot_node_path_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_node_path_get_name_count (VALUE p_self) {
  
  godot_int value = api->godot_node_path_get_name_count(rb_godot_node_path_pointer_to_godot(p_self));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_node_path_get_name (VALUE p_self, VALUE p_idx) {
  
  godot_string value = api->godot_node_path_get_name(rb_godot_node_path_pointer_to_godot(p_self), rb_godot_int_to_godot(p_idx));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_node_path_get_subname_count (VALUE p_self) {
  
  godot_int value = api->godot_node_path_get_subname_count(rb_godot_node_path_pointer_to_godot(p_self));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_node_path_get_subname (VALUE p_self, VALUE p_idx) {
  
  godot_string value = api->godot_node_path_get_subname(rb_godot_node_path_pointer_to_godot(p_self), rb_godot_int_to_godot(p_idx));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_node_path_get_concatenated_subnames (VALUE p_self) {
  
  godot_string value = api->godot_node_path_get_concatenated_subnames(rb_godot_node_path_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_node_path_is_empty (VALUE p_self) {
  
  godot_bool value = api->godot_node_path_is_empty(rb_godot_node_path_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_node_path_operator_equal (VALUE p_self, VALUE p_b) {
  
  godot_bool value = api->godot_node_path_operator_equal(rb_godot_node_path_pointer_to_godot(p_self), rb_godot_node_path_pointer_to_godot(p_b));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_pool_string_array_append (VALUE p_self, VALUE p_data) {
  
  api->godot_pool_string_array_append(rb_godot_pool_string_array_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_data));
  
  return Qnil;
}
VALUE rb_godot_pool_string_array_append_array (VALUE p_self, VALUE p_array) {
  
  api->godot_pool_string_array_append_array(rb_godot_pool_string_array_pointer_to_godot(p_self), rb_godot_pool_string_array_pointer_to_godot(p_array));
  
  return Qnil;
}
VALUE rb_godot_pool_string_array_insert (VALUE p_self, VALUE p_idx, VALUE p_data) {
  
  godot_error value = api->godot_pool_string_array_insert(rb_godot_pool_string_array_pointer_to_godot(p_self), rb_godot_int_to_godot(p_idx), rb_godot_string_pointer_to_godot(p_data));
  VALUE ret = rb_godot_error_from_godot(value);
  
  return ret;
}
VALUE rb_godot_pool_string_array_invert (VALUE p_self) {
  
  api->godot_pool_string_array_invert(rb_godot_pool_string_array_pointer_to_godot(p_self));
  
  return Qnil;
}
VALUE rb_godot_pool_string_array_push_back (VALUE p_self, VALUE p_data) {
  
  api->godot_pool_string_array_push_back(rb_godot_pool_string_array_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_data));
  
  return Qnil;
}
VALUE rb_godot_pool_string_array_remove (VALUE p_self, VALUE p_idx) {
  
  api->godot_pool_string_array_remove(rb_godot_pool_string_array_pointer_to_godot(p_self), rb_godot_int_to_godot(p_idx));
  
  return Qnil;
}
VALUE rb_godot_pool_string_array_resize (VALUE p_self, VALUE p_size) {
  
  api->godot_pool_string_array_resize(rb_godot_pool_string_array_pointer_to_godot(p_self), rb_godot_int_to_godot(p_size));
  
  return Qnil;
}
VALUE rb_godot_pool_string_array_set (VALUE p_self, VALUE p_idx, VALUE p_data) {
  
  api->godot_pool_string_array_set(rb_godot_pool_string_array_pointer_to_godot(p_self), rb_godot_int_to_godot(p_idx), rb_godot_string_pointer_to_godot(p_data));
  
  return Qnil;
}
VALUE rb_godot_pool_string_array_get (VALUE p_self, VALUE p_idx) {
  
  godot_string value = api->godot_pool_string_array_get(rb_godot_pool_string_array_pointer_to_godot(p_self), rb_godot_int_to_godot(p_idx));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_pool_string_array_size (VALUE p_self) {
  
  godot_int value = api->godot_pool_string_array_size(rb_godot_pool_string_array_pointer_to_godot(p_self));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_pool_string_array_destroy (VALUE p_self) {
  
  api->godot_pool_string_array_destroy(rb_godot_pool_string_array_pointer_to_godot(p_self));
  
  return Qnil;
}
VALUE rb_godot_string_operator_index (VALUE p_self, VALUE p_idx) {
  
  wchar_t * value = api->godot_string_operator_index(rb_godot_string_pointer_to_godot(p_self), rb_godot_int_to_godot(p_idx));
  VALUE ret = rb_wchar_t_pointer_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_operator_index_const (VALUE p_self, VALUE p_idx) {
  
  wchar_t value = api->godot_string_operator_index_const(rb_godot_string_pointer_to_godot(p_self), rb_godot_int_to_godot(p_idx));
  VALUE ret = rb_wchar_t_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_wide_str (VALUE p_self) {
  
  wchar_t * value = api->godot_string_wide_str(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_wchar_t_pointer_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_operator_equal (VALUE p_self, VALUE p_b) {
  
  godot_bool value = api->godot_string_operator_equal(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_b));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_operator_less (VALUE p_self, VALUE p_b) {
  
  godot_bool value = api->godot_string_operator_less(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_b));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_operator_plus (VALUE p_self, VALUE p_b) {
  
  godot_string value = api->godot_string_operator_plus(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_b));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_length (VALUE p_self) {
  
  godot_int value = api->godot_string_length(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_casecmp_to (VALUE p_self, VALUE p_str) {
  
  signed char value = api->godot_string_casecmp_to(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_str));
  VALUE ret = rb_signed_char_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_nocasecmp_to (VALUE p_self, VALUE p_str) {
  
  signed char value = api->godot_string_nocasecmp_to(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_str));
  VALUE ret = rb_signed_char_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_naturalnocasecmp_to (VALUE p_self, VALUE p_str) {
  
  signed char value = api->godot_string_naturalnocasecmp_to(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_str));
  VALUE ret = rb_signed_char_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_begins_with (VALUE p_self, VALUE p_string) {
  
  godot_bool value = api->godot_string_begins_with(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_string));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_bigrams (VALUE p_self) {
  
  godot_array value = api->godot_string_bigrams(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_array_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_ends_with (VALUE p_self, VALUE p_string) {
  
  godot_bool value = api->godot_string_ends_with(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_string));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_find (VALUE p_self, VALUE p_what) {
  
  godot_int value = api->godot_string_find(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_to_godot(p_what));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_find_from (VALUE p_self, VALUE p_what, VALUE p_from) {
  
  godot_int value = api->godot_string_find_from(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_to_godot(p_what), rb_godot_int_to_godot(p_from));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_findmk (VALUE p_self, VALUE p_keys) {
  
  godot_int value = api->godot_string_findmk(rb_godot_string_pointer_to_godot(p_self), rb_godot_array_pointer_to_godot(p_keys));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_findmk_from (VALUE p_self, VALUE p_keys, VALUE p_from) {
  
  godot_int value = api->godot_string_findmk_from(rb_godot_string_pointer_to_godot(p_self), rb_godot_array_pointer_to_godot(p_keys), rb_godot_int_to_godot(p_from));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_findn (VALUE p_self, VALUE p_what) {
  
  godot_int value = api->godot_string_findn(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_to_godot(p_what));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_findn_from (VALUE p_self, VALUE p_what, VALUE p_from) {
  
  godot_int value = api->godot_string_findn_from(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_to_godot(p_what), rb_godot_int_to_godot(p_from));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_find_last (VALUE p_self, VALUE p_what) {
  
  godot_int value = api->godot_string_find_last(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_to_godot(p_what));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_format (VALUE p_self, VALUE p_values) {
  godot_variant p_values_v = rb_godot_variant_to_godot(p_values);
  godot_string value = api->godot_string_format(rb_godot_string_pointer_to_godot(p_self), &p_values_v);
  VALUE ret = rb_godot_string_from_godot(value);
  api->godot_variant_destroy(&p_values_v);
  return ret;
}
VALUE rb_godot_string_hex_to_int (VALUE p_self) {
  
  godot_int value = api->godot_string_hex_to_int(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_hex_to_int_without_prefix (VALUE p_self) {
  
  godot_int value = api->godot_string_hex_to_int_without_prefix(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_insert (VALUE p_self, VALUE p_at_pos, VALUE p_string) {
  
  godot_string value = api->godot_string_insert(rb_godot_string_pointer_to_godot(p_self), rb_godot_int_to_godot(p_at_pos), rb_godot_string_to_godot(p_string));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_is_numeric (VALUE p_self) {
  
  godot_bool value = api->godot_string_is_numeric(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_is_subsequence_of (VALUE p_self, VALUE p_string) {
  
  godot_bool value = api->godot_string_is_subsequence_of(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_string));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_is_subsequence_ofi (VALUE p_self, VALUE p_string) {
  
  godot_bool value = api->godot_string_is_subsequence_ofi(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_string));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_lpad (VALUE p_self, VALUE p_min_length) {
  
  godot_string value = api->godot_string_lpad(rb_godot_string_pointer_to_godot(p_self), rb_godot_int_to_godot(p_min_length));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_lpad_with_custom_character (VALUE p_self, VALUE p_min_length, VALUE p_character) {
  
  godot_string value = api->godot_string_lpad_with_custom_character(rb_godot_string_pointer_to_godot(p_self), rb_godot_int_to_godot(p_min_length), rb_godot_string_pointer_to_godot(p_character));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_match (VALUE p_self, VALUE p_wildcard) {
  
  godot_bool value = api->godot_string_match(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_wildcard));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_matchn (VALUE p_self, VALUE p_wildcard) {
  
  godot_bool value = api->godot_string_matchn(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_wildcard));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_pad_decimals (VALUE p_self, VALUE p_digits) {
  
  godot_string value = api->godot_string_pad_decimals(rb_godot_string_pointer_to_godot(p_self), rb_godot_int_to_godot(p_digits));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_pad_zeros (VALUE p_self, VALUE p_digits) {
  
  godot_string value = api->godot_string_pad_zeros(rb_godot_string_pointer_to_godot(p_self), rb_godot_int_to_godot(p_digits));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_replace_first (VALUE p_self, VALUE p_key, VALUE p_with) {
  
  godot_string value = api->godot_string_replace_first(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_to_godot(p_key), rb_godot_string_to_godot(p_with));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_replace (VALUE p_self, VALUE p_key, VALUE p_with) {
  
  godot_string value = api->godot_string_replace(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_to_godot(p_key), rb_godot_string_to_godot(p_with));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_replacen (VALUE p_self, VALUE p_key, VALUE p_with) {
  
  godot_string value = api->godot_string_replacen(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_to_godot(p_key), rb_godot_string_to_godot(p_with));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_rfind (VALUE p_self, VALUE p_what) {
  
  godot_int value = api->godot_string_rfind(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_to_godot(p_what));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_rfindn (VALUE p_self, VALUE p_what) {
  
  godot_int value = api->godot_string_rfindn(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_to_godot(p_what));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_rfind_from (VALUE p_self, VALUE p_what, VALUE p_from) {
  
  godot_int value = api->godot_string_rfind_from(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_to_godot(p_what), rb_godot_int_to_godot(p_from));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_rfindn_from (VALUE p_self, VALUE p_what, VALUE p_from) {
  
  godot_int value = api->godot_string_rfindn_from(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_to_godot(p_what), rb_godot_int_to_godot(p_from));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_rpad (VALUE p_self, VALUE p_min_length) {
  
  godot_string value = api->godot_string_rpad(rb_godot_string_pointer_to_godot(p_self), rb_godot_int_to_godot(p_min_length));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_rpad_with_custom_character (VALUE p_self, VALUE p_min_length, VALUE p_character) {
  
  godot_string value = api->godot_string_rpad_with_custom_character(rb_godot_string_pointer_to_godot(p_self), rb_godot_int_to_godot(p_min_length), rb_godot_string_pointer_to_godot(p_character));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_similarity (VALUE p_self, VALUE p_string) {
  
  godot_real value = api->godot_string_similarity(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_string));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_substr (VALUE p_self, VALUE p_from, VALUE p_chars) {
  
  godot_string value = api->godot_string_substr(rb_godot_string_pointer_to_godot(p_self), rb_godot_int_to_godot(p_from), rb_godot_int_to_godot(p_chars));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_to_float (VALUE p_self) {
  
  godot_real value = api->godot_string_to_float(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_real_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_to_int (VALUE p_self) {
  
  godot_int value = api->godot_string_to_int(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_camelcase_to_underscore (VALUE p_self) {
  
  godot_string value = api->godot_string_camelcase_to_underscore(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_camelcase_to_underscore_lowercased (VALUE p_self) {
  
  godot_string value = api->godot_string_camelcase_to_underscore_lowercased(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_capitalize (VALUE p_self) {
  
  godot_string value = api->godot_string_capitalize(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_get_slice_count (VALUE p_self, VALUE p_splitter) {
  
  godot_int value = api->godot_string_get_slice_count(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_to_godot(p_splitter));
  VALUE ret = rb_godot_int_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_get_slice (VALUE p_self, VALUE p_splitter, VALUE p_slice) {
  
  godot_string value = api->godot_string_get_slice(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_to_godot(p_splitter), rb_godot_int_to_godot(p_slice));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_split (VALUE p_self, VALUE p_splitter) {
  
  godot_array value = api->godot_string_split(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_splitter));
  VALUE ret = rb_godot_array_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_split_allow_empty (VALUE p_self, VALUE p_splitter) {
  
  godot_array value = api->godot_string_split_allow_empty(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_splitter));
  VALUE ret = rb_godot_array_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_split_floats (VALUE p_self, VALUE p_splitter) {
  
  godot_array value = api->godot_string_split_floats(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_splitter));
  VALUE ret = rb_godot_array_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_split_floats_allows_empty (VALUE p_self, VALUE p_splitter) {
  
  godot_array value = api->godot_string_split_floats_allows_empty(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_splitter));
  VALUE ret = rb_godot_array_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_split_floats_mk (VALUE p_self, VALUE p_splitters) {
  
  godot_array value = api->godot_string_split_floats_mk(rb_godot_string_pointer_to_godot(p_self), rb_godot_array_pointer_to_godot(p_splitters));
  VALUE ret = rb_godot_array_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_split_floats_mk_allows_empty (VALUE p_self, VALUE p_splitters) {
  
  godot_array value = api->godot_string_split_floats_mk_allows_empty(rb_godot_string_pointer_to_godot(p_self), rb_godot_array_pointer_to_godot(p_splitters));
  VALUE ret = rb_godot_array_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_split_ints (VALUE p_self, VALUE p_splitter) {
  
  godot_array value = api->godot_string_split_ints(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_splitter));
  VALUE ret = rb_godot_array_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_split_ints_allows_empty (VALUE p_self, VALUE p_splitter) {
  
  godot_array value = api->godot_string_split_ints_allows_empty(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_splitter));
  VALUE ret = rb_godot_array_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_split_ints_mk (VALUE p_self, VALUE p_splitters) {
  
  godot_array value = api->godot_string_split_ints_mk(rb_godot_string_pointer_to_godot(p_self), rb_godot_array_pointer_to_godot(p_splitters));
  VALUE ret = rb_godot_array_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_split_ints_mk_allows_empty (VALUE p_self, VALUE p_splitters) {
  
  godot_array value = api->godot_string_split_ints_mk_allows_empty(rb_godot_string_pointer_to_godot(p_self), rb_godot_array_pointer_to_godot(p_splitters));
  VALUE ret = rb_godot_array_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_split_spaces (VALUE p_self) {
  
  godot_array value = api->godot_string_split_spaces(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_array_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_to_lower (VALUE p_self) {
  
  godot_string value = api->godot_string_to_lower(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_to_upper (VALUE p_self) {
  
  godot_string value = api->godot_string_to_upper(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_get_basename (VALUE p_self) {
  
  godot_string value = api->godot_string_get_basename(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_get_extension (VALUE p_self) {
  
  godot_string value = api->godot_string_get_extension(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_left (VALUE p_self, VALUE p_pos) {
  
  godot_string value = api->godot_string_left(rb_godot_string_pointer_to_godot(p_self), rb_godot_int_to_godot(p_pos));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_ord_at (VALUE p_self, VALUE p_idx) {
  
  wchar_t value = api->godot_string_ord_at(rb_godot_string_pointer_to_godot(p_self), rb_godot_int_to_godot(p_idx));
  VALUE ret = rb_wchar_t_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_plus_file (VALUE p_self, VALUE p_file) {
  
  godot_string value = api->godot_string_plus_file(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_file));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_right (VALUE p_self, VALUE p_pos) {
  
  godot_string value = api->godot_string_right(rb_godot_string_pointer_to_godot(p_self), rb_godot_int_to_godot(p_pos));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_strip_edges (VALUE p_self, VALUE p_left, VALUE p_right) {
  
  godot_string value = api->godot_string_strip_edges(rb_godot_string_pointer_to_godot(p_self), rb_godot_bool_to_godot(p_left), rb_godot_bool_to_godot(p_right));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_strip_escapes (VALUE p_self) {
  
  godot_string value = api->godot_string_strip_escapes(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_erase (VALUE p_self, VALUE p_pos, VALUE p_chars) {
  
  api->godot_string_erase(rb_godot_string_pointer_to_godot(p_self), rb_godot_int_to_godot(p_pos), rb_godot_int_to_godot(p_chars));
  
  return Qnil;
}
VALUE rb_godot_string_md5_text (VALUE p_self) {
  
  godot_string value = api->godot_string_md5_text(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_sha256_text (VALUE p_self) {
  
  godot_string value = api->godot_string_sha256_text(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_empty (VALUE p_self) {
  
  godot_bool value = api->godot_string_empty(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_get_base_dir (VALUE p_self) {
  
  godot_string value = api->godot_string_get_base_dir(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_get_file (VALUE p_self) {
  
  godot_string value = api->godot_string_get_file(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_is_abs_path (VALUE p_self) {
  
  godot_bool value = api->godot_string_is_abs_path(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_is_rel_path (VALUE p_self) {
  
  godot_bool value = api->godot_string_is_rel_path(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_is_resource_file (VALUE p_self) {
  
  godot_bool value = api->godot_string_is_resource_file(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_path_to (VALUE p_self, VALUE p_path) {
  
  godot_string value = api->godot_string_path_to(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_path));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_path_to_file (VALUE p_self, VALUE p_path) {
  
  godot_string value = api->godot_string_path_to_file(rb_godot_string_pointer_to_godot(p_self), rb_godot_string_pointer_to_godot(p_path));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_simplify_path (VALUE p_self) {
  
  godot_string value = api->godot_string_simplify_path(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_c_escape (VALUE p_self) {
  
  godot_string value = api->godot_string_c_escape(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_c_escape_multiline (VALUE p_self) {
  
  godot_string value = api->godot_string_c_escape_multiline(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_c_unescape (VALUE p_self) {
  
  godot_string value = api->godot_string_c_unescape(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_http_escape (VALUE p_self) {
  
  godot_string value = api->godot_string_http_escape(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_http_unescape (VALUE p_self) {
  
  godot_string value = api->godot_string_http_unescape(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_json_escape (VALUE p_self) {
  
  godot_string value = api->godot_string_json_escape(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_word_wrap (VALUE p_self, VALUE p_chars_per_line) {
  
  godot_string value = api->godot_string_word_wrap(rb_godot_string_pointer_to_godot(p_self), rb_godot_int_to_godot(p_chars_per_line));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_xml_escape (VALUE p_self) {
  
  godot_string value = api->godot_string_xml_escape(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_xml_escape_with_quotes (VALUE p_self) {
  
  godot_string value = api->godot_string_xml_escape_with_quotes(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_xml_unescape (VALUE p_self) {
  
  godot_string value = api->godot_string_xml_unescape(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_percent_decode (VALUE p_self) {
  
  godot_string value = api->godot_string_percent_decode(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_percent_encode (VALUE p_self) {
  
  godot_string value = api->godot_string_percent_encode(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_string_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_is_valid_float (VALUE p_self) {
  
  godot_bool value = api->godot_string_is_valid_float(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_is_valid_hex_number (VALUE p_self, VALUE p_with_prefix) {
  
  godot_bool value = api->godot_string_is_valid_hex_number(rb_godot_string_pointer_to_godot(p_self), rb_godot_bool_to_godot(p_with_prefix));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_is_valid_html_color (VALUE p_self) {
  
  godot_bool value = api->godot_string_is_valid_html_color(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_is_valid_identifier (VALUE p_self) {
  
  godot_bool value = api->godot_string_is_valid_identifier(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_is_valid_integer (VALUE p_self) {
  
  godot_bool value = api->godot_string_is_valid_integer(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_is_valid_ip_address (VALUE p_self) {
  
  godot_bool value = api->godot_string_is_valid_ip_address(rb_godot_string_pointer_to_godot(p_self));
  VALUE ret = rb_godot_bool_from_godot(value);
  
  return ret;
}
VALUE rb_godot_string_destroy (VALUE p_self) {
  
  api->godot_string_destroy(rb_godot_string_pointer_to_godot(p_self));
  
  return Qnil;
}
VALUE rb_godot_string_to_s(VALUE self) {
  godot_string *str = rb_godot_string_pointer_to_godot(self);
  VALUE ruby_str;
  godot_char_string char_string = api->godot_string_utf8(str);
  const char *chars = api->godot_char_string_get_data(&char_string);
  int len = api->godot_char_string_length(&char_string);
  ruby_str = rb_utf8_str_new(chars, len);
  api->godot_char_string_destroy(&char_string);
  return ruby_str;
}
VALUE rb_godot_aabb_type(VALUE self) {
  return LONG2FIX(GODOT_VARIANT_TYPE_AABB);
}
VALUE rb_godot_basis_type(VALUE self) {
  return LONG2FIX(GODOT_VARIANT_TYPE_BASIS);
}
VALUE rb_godot_color_type(VALUE self) {
  return LONG2FIX(GODOT_VARIANT_TYPE_COLOR);
}
VALUE rb_godot_plane_type(VALUE self) {
  return LONG2FIX(GODOT_VARIANT_TYPE_PLANE);
}
VALUE rb_godot_quat_type(VALUE self) {
  return LONG2FIX(GODOT_VARIANT_TYPE_QUAT);
}
VALUE rb_godot_rect2_type(VALUE self) {
  return LONG2FIX(GODOT_VARIANT_TYPE_RECT2);
}
VALUE rb_godot_transform_type(VALUE self) {
  return LONG2FIX(GODOT_VARIANT_TYPE_TRANSFORM);
}
VALUE rb_godot_transform2d_type(VALUE self) {
  return LONG2FIX(GODOT_VARIANT_TYPE_TRANSFORM2D);
}
VALUE rb_godot_vector2_type(VALUE self) {
  return LONG2FIX(GODOT_VARIANT_TYPE_VECTOR2);
}
VALUE rb_godot_vector3_type(VALUE self) {
  return LONG2FIX(GODOT_VARIANT_TYPE_VECTOR3);
}
VALUE rb_godot_array_type(VALUE self) {
  return LONG2FIX(GODOT_VARIANT_TYPE_ARRAY);
}
VALUE rb_godot_dictionary_type(VALUE self) {
  return LONG2FIX(GODOT_VARIANT_TYPE_DICTIONARY);
}
VALUE rb_godot_node_path_type(VALUE self) {
  return LONG2FIX(GODOT_VARIANT_TYPE_NODE_PATH);
}
VALUE rb_godot_object_type(VALUE self) {
  return LONG2FIX(GODOT_VARIANT_TYPE_OBJECT);
}
VALUE rb_godot_pool_string_array_type(VALUE self) {
  return LONG2FIX(GODOT_VARIANT_TYPE_POOL_STRING_ARRAY);
}
VALUE rb_godot_string_type(VALUE self) {
  return LONG2FIX(GODOT_VARIANT_TYPE_STRING);
}
const char *RUBY_CODE = "module Godot\n\
  def self._register_class path, code\n\
    @_classes ||= {}\n\
    klass = ::Class.new(Godot::Object)\n\
    klass.include Godot::AttachedScript\n\
    klass.class_eval(code, path)\n\
    @_classes[klass.object_id] = klass\n\
    klass\n\
  rescue Exception => e\n\
    Godot._print_error e\n\
    klass = ::Class.new(Godot::Object)\n\
    klass.include Godot::AttachedScript\n\
    klass\n\
  end\n\
\n\
  def self._unregister_class klass\n\
    @_classes.delete(klass.object_id)\n\
  end\n\
\n\
  def self.call_method obj, name, *args\n\
    obj.send(name, *args)\n\
  rescue Exception => e\n\
    Godot._print_error e\n\
    nil\n\
  end\n\
\n\
  def self.built_in_type_class\n\
    @_built_in_type_class ||= ::Class.new do\n\
      class << self\n\
        def _adopt addr\n\
          obj = allocate\n\
          obj.instance_variable_set(:@_godot_address, addr)\n\
          ObjectSpace.define_finalizer(obj, finalizer_proc(addr))\n\
          obj\n\
        end\n\
\n\
        def finalizer_proc addr\n\
          proc { self._finalize addr }\n\
        end\n\
\n\
        def const_missing name\n\
          if Engine.has_singleton(name)\n\
            Godot.const_set(name, Godot._get_singleton(name.to_s))\n\
          else\n\
            Godot.const_set(name, Godot::Class.new(name))\n\
          end\n\
        end\n\
\n\
        def [] *args\n\
          new *args\n\
        end\n\
      end\n\
\n\
    end\n\
  end\n\
\n\
  def self._template_source_code base_name\n\
    Godot::String.new <<~EOF\n\
      extends :#{base_name}\n\
\n\
      def _ready\n\
\n\
      end\n\
    EOF\n\
  end\n\
\n\
  def self._define_constants pool_string_array\n\
    pool_string_array.size.times do |i|\n\
      name = pool_string_array.get(i).to_s\n\
      Godot.const_set(name, Godot._get_singleton(name))\n\
    end\n\
  end\n\
\n\
  def self._initialize_singletons\n\
    singletons = [\"ResourceLoader\", \"ResourceSaver\", \"OS\", \"Geometry\", \"ClassDB\", \"Engine\", \"AudioServer\", \"ProjectSettings\", \"Input\", \"InputMap\", \"Marshalls\", \"Performance\", \"Physics2DServer\", \"PhysicsServer\", \"TranslationServer\", \"VisualServer\"]\n\
    singletons.each do |name|\n\
      Godot.const_set(name, Godot._get_singleton(name))\n\
    end\n\
    ['TCPServer', 'File', 'Thread', 'Mutex', 'Range'].each do |name|\n\
      Godot.const_set(name, Godot::Class.new(name))\n\
    end\n\
  end\n\
\n\
  def self._initialize_io\n\
    io_class = ::Class.new(IO) do\n\
      def write data\n\
        str = data.to_s.chomp\n\
        unless str.empty?\n\
          Godot._print String.new(str)\n\
        end\n\
      end\n\
    end\n\
\n\
    godot_io = io_class.new(1)\n\
    $stdout.reopen(godot_io)\n\
  end\n\
\n\
  def self._initialize_constants\n\
    @_godot_constants = @_godot_constants.to_h.map do |name, int|\n\
      [name.to_s, int]\n\
    end.to_h\n\
    @_godot_constants.each do |name, int|\n\
      Godot.const_set(name, int)\n\
    end\n\
  end\n\
\n\
  def self._initialize\n\
    _initialize_singletons\n\
    _initialize_io\n\
    _initialize_constants\n\
  rescue Exception => e\n\
    Godot._print_error e\n\
  end\n\
\n\
  def self._register_object obj\n\
    @_objects ||= {}\n\
    @_objects[obj.object_id] = obj\n\
  end\n\
\n\
  def self._unregister_object obj\n\
    @_objects.delete(obj.object_id)\n\
  end\n\
\n\
  def self._script_manifest klass\n\
    klass.instance_eval do\n\
      [\n\
        #name:\n\
        String.new('anonymous'),\n\
        #tool:\n\
        @_tool ? 1 : 0,\n\
        #base:\n\
        String.new(@_base_name || 'Object'),\n\
        #member_lines:\n\
        Dictionary.new({}),\n\
        #methods:\n\
        Array.new(instance_methods(false).map{|m|\n\
          {\n\
            name: m,\n\
            args: [],\n\
            default_args: [],\n\
            return: {},\n\
            flags: 1,\n\
            rpc_mode: 0\n\
          }\n\
        }),\n\
        #signals:\n\
        Array.new(@_signals.to_a.map{|s|\n\
          {\n\
            name: s[:name],\n\
            args: s[:args].map{|arg|\n\
              {\n\
                name: arg\n\
              }\n\
            },\n\
            default_args: [],\n\
            return: {},\n\
            flags: 1,\n\
            rpc_mode: 0\n\
          }\n\
        }),\n\
        #properties:\n\
        Array.new(@_exports.to_a.map{|p|\n\
          {\n\
            name: p[:name],\n\
            type: p[:type],\n\
            hint: p[:hint],\n\
            hint_string: p[:hint_string],\n\
            usage: 8199,\n\
            default_value: p[:default_value],\n\
            rset_mode: 0\n\
          }\n\
        })\n\
      ]\n\
    end\n\
  end\n\
end\n\
module Godot\n\
  class Object < Godot.built_in_type_class\n\
    def method_missing name, *args, &block\n\
      if respond_to? name\n\
        puts \"super to Godot::Object will lead to endless loop\"\n\
      else\n\
        _call name, args\n\
      end\n\
    end\n\
  end\n\
end\n\
module Godot\n\
  class Class\n\
    def initialize name\n\
      @name = name\n\
    end\n\
\n\
    def new\n\
      ClassDB.instance(String.new(\"Node\"))\n\
    end\n\
  end\n\
end\n\
module Godot\n\
  module AttachedScript\n\
    module ClassMethods\n\
      attr_reader :_exports, :_signals\n\
\n\
      def extends name\n\
        @_base_name = name.to_s\n\
      end\n\
\n\
      def export name, _type, **options\n\
        case _type\n\
        when :int\n\
          type = TYPE_INT\n\
          if options[:range]\n\
            hint = PROPERTY_HINT_RANGE\n\
            hint_string = [options[:range].min, options[:range].max, options[:step]].compact.join(',')\n\
          elsif options[:enum]\n\
            hint = PROPERTY_HINT_ENUM\n\
            hint_string = options[:enum].join(',')\n\
          end\n\
        when :float\n\
          type = TYPE_REAL\n\
          if options[:range]\n\
            hint = PROPERTY_HINT_RANGE\n\
            hint_string = [options[:range].min, options[:range].max, options[:step]].compact.join(',')\n\
          end\n\
        when :String\n\
          type = TYPE_STRING\n\
          if options[:enum]\n\
            hint = PROPERTY_HINT_ENUM\n\
            hint_string = options[:enum].join(',')\n\
          end\n\
        when :exp\n\
          type = TYPE_REAL\n\
          hint = PROPERTY_HINT_EXP_RANGE\n\
          hint_string = [options[:range].min, options[:range].max, options[:step]].compact.join(',')\n\
        when :ease\n\
          type = TYPE_REAL\n\
          hint = PROPERTY_HINT_EXP_EASING\n\
        when :file\n\
          type = TYPE_STRING\n\
          hint = PROPERTY_HINT_FILE\n\
          if options[:extension]\n\
            hint_string = options[:extension]\n\
          end\n\
        when :global_file\n\
          type = TYPE_STRING\n\
          hint = PROPERTY_HINT_GLOBAL_FILE\n\
          if options[:extension]\n\
            hint_string = options[:extension]\n\
          end\n\
        when :dir\n\
          type = TYPE_STRING\n\
          hint = PROPERTY_HINT_DIR\n\
          if options[:extension]\n\
            hint_string = options[:extension]\n\
          end\n\
        when :global_dir\n\
          type = TYPE_STRING\n\
          hint = PROPERTY_HINT_GLOBAL_DIR\n\
          if options[:extension]\n\
            hint_string = options[:extension]\n\
          end\n\
        when :multiline\n\
          type = TYPE_STRING\n\
          hint = PROPERTY_HINT_MULTILINE_TEXT\n\
        when :rgb\n\
          type = TYPE_COLOR\n\
          hint = PROPERTY_HINT_COLOR_NO_ALPHA\n\
        when :rgba\n\
          type = TYPE_COLOR\n\
\n\
        when :bool\n\
          type = TYPE_BOOL\n\
        when :Vector2\n\
          type = TYPE_VECTOR2\n\
        when :Rect2\n\
          type = TYPE_RECT2\n\
        when :Vector3\n\
          type = TYPE_VECTOR3\n\
        when :Transform2D\n\
          type = TYPE_TRANSFORM2D\n\
        when :Plane\n\
          type = TYPE_PLANE\n\
        when :Quat\n\
          type = TYPE_QUAT\n\
        when :Aabb\n\
          type = TYPE_AABB\n\
        when :Basis\n\
          type = TYPE_BASIS\n\
        when :Transform\n\
          type = TYPE_TRANSFORM\n\
        when :NodePath\n\
          type = TYPE_NODE_PATH\n\
        when :Rid\n\
          type = TYPE_RID\n\
        when :Dictionary\n\
          type = TYPE_DICTIONARY\n\
        when :Array\n\
          type = TYPE_ARRAY\n\
        when :PoolIntArray\n\
          type = TYPE_INT_ARRAY\n\
        when :PoolStringArray\n\
          type = TYPE_STRING_ARRAY\n\
        when :PoolVector2Array\n\
          type = PoolVector2Array\n\
        when :PoolVector3Array\n\
          type = TYPE_VECTOR3_ARRAY\n\
        when :PoolColorArray\n\
          type = TYPE_COLOR_ARRAY\n\
\n\
        else\n\
          type = TYPE_OBJECT\n\
          hint = PROPERTY_HINT_RESOURCE_TYPE\n\
        end\n\
\n\
        @_exports ||= []\n\
        @_exports << {name: name, type: type, hint: hint || PROPERTY_HINT_NONE, hint_string: hint_string || '', default_value: options[:default]}\n\
      end\n\
\n\
      def signal name, args = []\n\
        raise \"signal arguments should be an array\" if !args.is_a?(::Array)\n\
        @_signals ||= []\n\
        @_signals << {\n\
          name: name,\n\
          args: args\n\
        }\n\
      end\n\
\n\
      def tool\n\
        @_tool = true\n\
      end\n\
    end\n\
\n\
    module InstanceMethods\n\
      def initialize\n\
        Godot._register_object self\n\
      end\n\
    end\n\
\n\
    def self.included base\n\
      base.extend ClassMethods\n\
      base.include InstanceMethods\n\
    end\n\
  end\n\
end\n\
module Godot\n\
  class Aabb < Godot.built_in_type_class\n\
    def initialize *args\n\
  case\n\
  when (args[0].is_a?(Godot::Vector3)) && (args[1].is_a?(Godot::Vector3)) then _initialize(*args)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  ObjectSpace.define_finalizer(self, self.class.finalizer_proc(@_godot_address))\n\
\n\
end\n\
\n\
    \n\
  end\n\
end\n\
module Godot\n\
  class Basis < Godot.built_in_type_class\n\
    def initialize *args\n\
  case\n\
  when (args[0].is_a?(Godot::Vector3)) && (args[1].is_a?(Godot::Vector3)) && (args[2].is_a?(Godot::Vector3)) then _initialize_with_rows(*args)\n\
when (args[0].is_a?(Godot::Vector3)) && (args[1].is_a?(Numeric)) then _initialize_with_axis_and_angle(*args)\n\
when (args[0].is_a?(Godot::Vector3)) then _initialize_with_euler(*args)\n\
when (args[0].is_a?(Godot::Quat)) then _initialize_with_euler_quat(*args)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  ObjectSpace.define_finalizer(self, self.class.finalizer_proc(@_godot_address))\n\
\n\
end\n\
\n\
    def * *args\n\
  case\n\
  when (args[0].is_a?(Godot::Basis)) then operator_multiply_vector(*args)\n\
when (args[0].is_a?(Numeric)) then operator_multiply_scalar(*args)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  \n\
end\n\
\n\
  end\n\
end\n\
module Godot\n\
  class Color < Godot.built_in_type_class\n\
    def initialize *args\n\
  case\n\
  when (args[0].is_a?(Numeric)) && (args[1].is_a?(Numeric)) && (args[2].is_a?(Numeric)) && (args[3].is_a?(Numeric)) then _initialize_rgba(*args)\n\
when (args[0].is_a?(Numeric)) && (args[1].is_a?(Numeric)) && (args[2].is_a?(Numeric)) then _initialize_rgb(*args)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  ObjectSpace.define_finalizer(self, self.class.finalizer_proc(@_godot_address))\n\
\n\
end\n\
\n\
    \n\
  end\n\
end\n\
module Godot\n\
  class Plane < Godot.built_in_type_class\n\
    def initialize *args\n\
  case\n\
  when (args[0].is_a?(Numeric)) && (args[1].is_a?(Numeric)) && (args[2].is_a?(Numeric)) && (args[3].is_a?(Numeric)) then _initialize_with_reals(*args)\n\
when (args[0].is_a?(Godot::Vector3)) && (args[1].is_a?(Godot::Vector3)) && (args[2].is_a?(Godot::Vector3)) then _initialize_with_vectors(*args)\n\
when (args[0].is_a?(Godot::Vector3)) && (args[1].is_a?(Numeric)) then _initialize_with_normal(*args)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  ObjectSpace.define_finalizer(self, self.class.finalizer_proc(@_godot_address))\n\
\n\
end\n\
\n\
    \n\
  end\n\
end\n\
module Godot\n\
  class Quat < Godot.built_in_type_class\n\
    def initialize *args\n\
  case\n\
  when (args[0].is_a?(Numeric)) && (args[1].is_a?(Numeric)) && (args[2].is_a?(Numeric)) && (args[3].is_a?(Numeric)) then _initialize(*args)\n\
when (args[0].is_a?(Godot::Vector3)) && (args[1].is_a?(Numeric)) then _initialize_with_axis_angle(*args)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  ObjectSpace.define_finalizer(self, self.class.finalizer_proc(@_godot_address))\n\
\n\
end\n\
\n\
    \n\
  end\n\
end\n\
module Godot\n\
  class Rect2 < Godot.built_in_type_class\n\
    def initialize *args\n\
  case\n\
  when (args[0].is_a?(Godot::Vector2)) && (args[1].is_a?(Godot::Vector2)) then _initialize_with_position_and_size(*args)\n\
when (args[0].is_a?(Numeric)) && (args[1].is_a?(Numeric)) && (args[2].is_a?(Numeric)) && (args[3].is_a?(Numeric)) then _initialize(*args)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  ObjectSpace.define_finalizer(self, self.class.finalizer_proc(@_godot_address))\n\
\n\
end\n\
\n\
    \n\
  end\n\
end\n\
module Godot\n\
  class Transform < Godot.built_in_type_class\n\
    def initialize *args\n\
  case\n\
  when (args[0].is_a?(Godot::Vector3)) && (args[1].is_a?(Godot::Vector3)) && (args[2].is_a?(Godot::Vector3)) && (args[3].is_a?(Godot::Vector3)) then _initialize_with_axis_origin(*args)\n\
when (args[0].is_a?(Godot::Basis)) && (args[1].is_a?(Godot::Vector3)) then _initialize(*args)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  ObjectSpace.define_finalizer(self, self.class.finalizer_proc(@_godot_address))\n\
\n\
end\n\
\n\
    \n\
  end\n\
end\n\
module Godot\n\
  class Transform2D < Godot.built_in_type_class\n\
    def initialize *args\n\
  case\n\
  when (args[0].is_a?(Numeric)) && (args[1].is_a?(Godot::Vector2)) then _initialize(*args)\n\
when (args[0].is_a?(Godot::Vector2)) && (args[1].is_a?(Godot::Vector2)) && (args[2].is_a?(Godot::Vector2)) then _initialize_axis_origin(*args)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  ObjectSpace.define_finalizer(self, self.class.finalizer_proc(@_godot_address))\n\
\n\
end\n\
\n\
    \n\
  end\n\
end\n\
module Godot\n\
  class Vector2 < Godot.built_in_type_class\n\
    def initialize *args\n\
  case\n\
  when (args[0].is_a?(Numeric)) && (args[1].is_a?(Numeric)) then _initialize(*args)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  ObjectSpace.define_finalizer(self, self.class.finalizer_proc(@_godot_address))\n\
\n\
end\n\
\n\
    def * *args\n\
  case\n\
  when (args[0].is_a?(Godot::Vector2)) then operator_multiply_vector(*args)\n\
when (args[0].is_a?(Numeric)) then operator_multiply_scalar(*args)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  \n\
end\n\
\n\
def / *args\n\
  case\n\
  when (args[0].is_a?(Godot::Vector2)) then operator_divide_vector(*args)\n\
when (args[0].is_a?(Numeric)) then operator_divide_scalar(*args)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  \n\
end\n\
\n\
  end\n\
end\n\
module Godot\n\
  class Vector3 < Godot.built_in_type_class\n\
    def initialize *args\n\
  case\n\
  when (args[0].is_a?(Numeric)) && (args[1].is_a?(Numeric)) && (args[2].is_a?(Numeric)) then _initialize(*args)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  ObjectSpace.define_finalizer(self, self.class.finalizer_proc(@_godot_address))\n\
\n\
end\n\
\n\
    def * *args\n\
  case\n\
  when (args[0].is_a?(Godot::Vector3)) then operator_multiply_vector(*args)\n\
when (args[0].is_a?(Numeric)) then operator_multiply_scalar(*args)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  \n\
end\n\
\n\
def / *args\n\
  case\n\
  when (args[0].is_a?(Godot::Vector3)) then operator_divide_vector(*args)\n\
when (args[0].is_a?(Numeric)) then operator_divide_scalar(*args)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  \n\
end\n\
\n\
  end\n\
end\n\
module Godot\n\
  class Array < Godot.built_in_type_class\n\
    def initialize arg\n\
  if arg.is_a?(::Array) || arg.is_a?(Godot::Array)\n\
    _initialize(arg)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  ObjectSpace.define_finalizer(self, self.class.finalizer_proc(@_godot_address))\n\
end\n\
\n\
  end\n\
end\n\
module Godot\n\
  class Dictionary < Godot.built_in_type_class\n\
    def initialize arg\n\
  if arg.is_a?(::Hash) || arg.is_a?(Godot::Dictionary)\n\
    _initialize(arg)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  ObjectSpace.define_finalizer(self, self.class.finalizer_proc(@_godot_address))\n\
end\n\
\n\
  end\n\
end\n\
module Godot\n\
  class NodePath < Godot.built_in_type_class\n\
    def initialize arg\n\
  if arg.is_a?(::String) || arg.is_a?(Godot::String)\n\
    _initialize(arg)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  ObjectSpace.define_finalizer(self, self.class.finalizer_proc(@_godot_address))\n\
end\n\
\n\
  end\n\
end\n\
module Godot\n\
  class Object < Godot.built_in_type_class\n\
    \n\
  end\n\
end\n\
module Godot\n\
  class PoolStringArray < Godot.built_in_type_class\n\
    def initialize arg\n\
  if \n\
    _initialize(arg)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  ObjectSpace.define_finalizer(self, self.class.finalizer_proc(@_godot_address))\n\
end\n\
\n\
  end\n\
end\n\
module Godot\n\
  class String < Godot.built_in_type_class\n\
    def initialize arg\n\
  if arg.is_a?(::String) || arg.is_a?(Godot::String)\n\
    _initialize(arg)\n\
  else\n\
    raise \"mismatched arguments\"\n\
  end\n\
  ObjectSpace.define_finalizer(self, self.class.finalizer_proc(@_godot_address))\n\
end\n\
\n\
  end\n\
end\n\
";

void init() {
  VALUE godot_module = rb_const_get(rb_cModule, rb_intern("Godot"));
Aabb_class = rb_const_get(godot_module, rb_intern("Aabb"));
Basis_class = rb_const_get(godot_module, rb_intern("Basis"));
Color_class = rb_const_get(godot_module, rb_intern("Color"));
Plane_class = rb_const_get(godot_module, rb_intern("Plane"));
Quat_class = rb_const_get(godot_module, rb_intern("Quat"));
Rect2_class = rb_const_get(godot_module, rb_intern("Rect2"));
Transform_class = rb_const_get(godot_module, rb_intern("Transform"));
Transform2D_class = rb_const_get(godot_module, rb_intern("Transform2D"));
Vector2_class = rb_const_get(godot_module, rb_intern("Vector2"));
Vector3_class = rb_const_get(godot_module, rb_intern("Vector3"));
Array_class = rb_const_get(godot_module, rb_intern("Array"));
Dictionary_class = rb_const_get(godot_module, rb_intern("Dictionary"));
NodePath_class = rb_const_get(godot_module, rb_intern("NodePath"));
Object_class = rb_const_get(godot_module, rb_intern("Object"));
PoolStringArray_class = rb_const_get(godot_module, rb_intern("PoolStringArray"));
String_class = rb_const_get(godot_module, rb_intern("String"));

  rb_define_method(Aabb_class, "_initialize", &rb_godot_aabb_initialize, 2);
rb_define_method(Aabb_class, "get_position", &rb_godot_aabb_get_position, 0);
rb_define_method(Aabb_class, "set_position", &rb_godot_aabb_set_position, 1);
rb_define_method(Aabb_class, "get_size", &rb_godot_aabb_get_size, 0);
rb_define_method(Aabb_class, "set_size", &rb_godot_aabb_set_size, 1);
rb_define_method(Aabb_class, "as_string", &rb_godot_aabb_as_string, 0);
rb_define_method(Aabb_class, "get_area", &rb_godot_aabb_get_area, 0);
rb_define_method(Aabb_class, "has_no_area", &rb_godot_aabb_has_no_area, 0);
rb_define_method(Aabb_class, "has_no_surface", &rb_godot_aabb_has_no_surface, 0);
rb_define_method(Aabb_class, "intersects", &rb_godot_aabb_intersects, 1);
rb_define_method(Aabb_class, "encloses", &rb_godot_aabb_encloses, 1);
rb_define_method(Aabb_class, "merge", &rb_godot_aabb_merge, 1);
rb_define_method(Aabb_class, "intersection", &rb_godot_aabb_intersection, 1);
rb_define_method(Aabb_class, "intersects_plane", &rb_godot_aabb_intersects_plane, 1);
rb_define_method(Aabb_class, "intersects_segment", &rb_godot_aabb_intersects_segment, 2);
rb_define_method(Aabb_class, "has_point", &rb_godot_aabb_has_point, 1);
rb_define_method(Aabb_class, "get_support", &rb_godot_aabb_get_support, 1);
rb_define_method(Aabb_class, "get_longest_axis", &rb_godot_aabb_get_longest_axis, 0);
rb_define_method(Aabb_class, "get_longest_axis_index", &rb_godot_aabb_get_longest_axis_index, 0);
rb_define_method(Aabb_class, "get_longest_axis_size", &rb_godot_aabb_get_longest_axis_size, 0);
rb_define_method(Aabb_class, "get_shortest_axis", &rb_godot_aabb_get_shortest_axis, 0);
rb_define_method(Aabb_class, "get_shortest_axis_index", &rb_godot_aabb_get_shortest_axis_index, 0);
rb_define_method(Aabb_class, "get_shortest_axis_size", &rb_godot_aabb_get_shortest_axis_size, 0);
rb_define_method(Aabb_class, "expand", &rb_godot_aabb_expand, 1);
rb_define_method(Aabb_class, "grow", &rb_godot_aabb_grow, 1);
rb_define_method(Aabb_class, "get_endpoint", &rb_godot_aabb_get_endpoint, 1);
rb_define_method(Aabb_class, "operator_equal", &rb_godot_aabb_operator_equal, 1);
rb_define_singleton_method(Aabb_class, "_finalize", &rb_godot_aabb_finalize, 1);
rb_define_method(Aabb_class, "_type", &rb_godot_aabb_type, 0);
rb_define_alias(Aabb_class, "==", "operator_equal");
rb_define_method(Basis_class, "_initialize_with_rows", &rb_godot_basis_initialize_with_rows, 3);
rb_define_method(Basis_class, "_initialize_with_axis_and_angle", &rb_godot_basis_initialize_with_axis_and_angle, 2);
rb_define_method(Basis_class, "_initialize_with_euler", &rb_godot_basis_initialize_with_euler, 1);
rb_define_method(Basis_class, "_initialize_with_euler_quat", &rb_godot_basis_initialize_with_euler_quat, 1);
rb_define_method(Basis_class, "as_string", &rb_godot_basis_as_string, 0);
rb_define_method(Basis_class, "inverse", &rb_godot_basis_inverse, 0);
rb_define_method(Basis_class, "transposed", &rb_godot_basis_transposed, 0);
rb_define_method(Basis_class, "orthonormalized", &rb_godot_basis_orthonormalized, 0);
rb_define_method(Basis_class, "determinant", &rb_godot_basis_determinant, 0);
rb_define_method(Basis_class, "rotated", &rb_godot_basis_rotated, 2);
rb_define_method(Basis_class, "scaled", &rb_godot_basis_scaled, 1);
rb_define_method(Basis_class, "get_scale", &rb_godot_basis_get_scale, 0);
rb_define_method(Basis_class, "get_euler", &rb_godot_basis_get_euler, 0);
rb_define_method(Basis_class, "tdotx", &rb_godot_basis_tdotx, 1);
rb_define_method(Basis_class, "tdoty", &rb_godot_basis_tdoty, 1);
rb_define_method(Basis_class, "tdotz", &rb_godot_basis_tdotz, 1);
rb_define_method(Basis_class, "xform", &rb_godot_basis_xform, 1);
rb_define_method(Basis_class, "xform_inv", &rb_godot_basis_xform_inv, 1);
rb_define_method(Basis_class, "get_orthogonal_index", &rb_godot_basis_get_orthogonal_index, 0);
rb_define_method(Basis_class, "get_elements", &rb_godot_basis_get_elements, 1);
rb_define_method(Basis_class, "get_axis", &rb_godot_basis_get_axis, 1);
rb_define_method(Basis_class, "set_axis", &rb_godot_basis_set_axis, 2);
rb_define_method(Basis_class, "get_row", &rb_godot_basis_get_row, 1);
rb_define_method(Basis_class, "set_row", &rb_godot_basis_set_row, 2);
rb_define_method(Basis_class, "operator_equal", &rb_godot_basis_operator_equal, 1);
rb_define_method(Basis_class, "operator_add", &rb_godot_basis_operator_add, 1);
rb_define_method(Basis_class, "operator_subtract", &rb_godot_basis_operator_subtract, 1);
rb_define_method(Basis_class, "operator_multiply_vector", &rb_godot_basis_operator_multiply_vector, 1);
rb_define_method(Basis_class, "operator_multiply_scalar", &rb_godot_basis_operator_multiply_scalar, 1);
rb_define_singleton_method(Basis_class, "_finalize", &rb_godot_basis_finalize, 1);
rb_define_method(Basis_class, "_type", &rb_godot_basis_type, 0);
rb_define_alias(Basis_class, "==", "operator_equal");
rb_define_alias(Basis_class, "+", "operator_add");
rb_define_alias(Basis_class, "-", "operator_subtract");
rb_define_method(Color_class, "_initialize_rgba", &rb_godot_color_initialize_rgba, 4);
rb_define_method(Color_class, "_initialize_rgb", &rb_godot_color_initialize_rgb, 3);
rb_define_method(Color_class, "get_r", &rb_godot_color_get_r, 0);
rb_define_method(Color_class, "set_r", &rb_godot_color_set_r, 1);
rb_define_method(Color_class, "get_g", &rb_godot_color_get_g, 0);
rb_define_method(Color_class, "set_g", &rb_godot_color_set_g, 1);
rb_define_method(Color_class, "get_b", &rb_godot_color_get_b, 0);
rb_define_method(Color_class, "set_b", &rb_godot_color_set_b, 1);
rb_define_method(Color_class, "get_a", &rb_godot_color_get_a, 0);
rb_define_method(Color_class, "set_a", &rb_godot_color_set_a, 1);
rb_define_method(Color_class, "get_h", &rb_godot_color_get_h, 0);
rb_define_method(Color_class, "get_s", &rb_godot_color_get_s, 0);
rb_define_method(Color_class, "get_v", &rb_godot_color_get_v, 0);
rb_define_method(Color_class, "as_string", &rb_godot_color_as_string, 0);
rb_define_method(Color_class, "to_rgba32", &rb_godot_color_to_rgba32, 0);
rb_define_method(Color_class, "to_argb32", &rb_godot_color_to_argb32, 0);
rb_define_method(Color_class, "gray", &rb_godot_color_gray, 0);
rb_define_method(Color_class, "inverted", &rb_godot_color_inverted, 0);
rb_define_method(Color_class, "contrasted", &rb_godot_color_contrasted, 0);
rb_define_method(Color_class, "linear_interpolate", &rb_godot_color_linear_interpolate, 2);
rb_define_method(Color_class, "blend", &rb_godot_color_blend, 1);
rb_define_method(Color_class, "to_html", &rb_godot_color_to_html, 1);
rb_define_method(Color_class, "operator_equal", &rb_godot_color_operator_equal, 1);
rb_define_method(Color_class, "operator_less", &rb_godot_color_operator_less, 1);
rb_define_singleton_method(Color_class, "_finalize", &rb_godot_color_finalize, 1);
rb_define_method(Color_class, "_type", &rb_godot_color_type, 0);
rb_define_alias(Color_class, "==", "operator_equal");
rb_define_alias(Color_class, "<", "operator_less");
rb_define_method(Plane_class, "_initialize_with_reals", &rb_godot_plane_initialize_with_reals, 4);
rb_define_method(Plane_class, "_initialize_with_vectors", &rb_godot_plane_initialize_with_vectors, 3);
rb_define_method(Plane_class, "_initialize_with_normal", &rb_godot_plane_initialize_with_normal, 2);
rb_define_method(Plane_class, "as_string", &rb_godot_plane_as_string, 0);
rb_define_method(Plane_class, "normalized", &rb_godot_plane_normalized, 0);
rb_define_method(Plane_class, "center", &rb_godot_plane_center, 0);
rb_define_method(Plane_class, "get_any_point", &rb_godot_plane_get_any_point, 0);
rb_define_method(Plane_class, "is_point_over", &rb_godot_plane_is_point_over, 1);
rb_define_method(Plane_class, "distance_to", &rb_godot_plane_distance_to, 1);
rb_define_method(Plane_class, "has_point", &rb_godot_plane_has_point, 2);
rb_define_method(Plane_class, "project", &rb_godot_plane_project, 1);
rb_define_method(Plane_class, "intersect_3", &rb_godot_plane_intersect_3, 3);
rb_define_method(Plane_class, "intersects_ray", &rb_godot_plane_intersects_ray, 3);
rb_define_method(Plane_class, "intersects_segment", &rb_godot_plane_intersects_segment, 3);
rb_define_method(Plane_class, "operator_neg", &rb_godot_plane_operator_neg, 0);
rb_define_method(Plane_class, "operator_equal", &rb_godot_plane_operator_equal, 1);
rb_define_method(Plane_class, "set_normal", &rb_godot_plane_set_normal, 1);
rb_define_method(Plane_class, "get_normal", &rb_godot_plane_get_normal, 0);
rb_define_method(Plane_class, "get_d", &rb_godot_plane_get_d, 0);
rb_define_method(Plane_class, "set_d", &rb_godot_plane_set_d, 1);
rb_define_singleton_method(Plane_class, "_finalize", &rb_godot_plane_finalize, 1);
rb_define_method(Plane_class, "_type", &rb_godot_plane_type, 0);
rb_define_alias(Plane_class, "-@", "operator_neg");
rb_define_alias(Plane_class, "==", "operator_equal");
rb_define_method(Quat_class, "_initialize", &rb_godot_quat_initialize, 4);
rb_define_method(Quat_class, "_initialize_with_axis_angle", &rb_godot_quat_initialize_with_axis_angle, 2);
rb_define_method(Quat_class, "get_x", &rb_godot_quat_get_x, 0);
rb_define_method(Quat_class, "set_x", &rb_godot_quat_set_x, 1);
rb_define_method(Quat_class, "get_y", &rb_godot_quat_get_y, 0);
rb_define_method(Quat_class, "set_y", &rb_godot_quat_set_y, 1);
rb_define_method(Quat_class, "get_z", &rb_godot_quat_get_z, 0);
rb_define_method(Quat_class, "set_z", &rb_godot_quat_set_z, 1);
rb_define_method(Quat_class, "get_w", &rb_godot_quat_get_w, 0);
rb_define_method(Quat_class, "set_w", &rb_godot_quat_set_w, 1);
rb_define_method(Quat_class, "as_string", &rb_godot_quat_as_string, 0);
rb_define_method(Quat_class, "length", &rb_godot_quat_length, 0);
rb_define_method(Quat_class, "length_squared", &rb_godot_quat_length_squared, 0);
rb_define_method(Quat_class, "normalized", &rb_godot_quat_normalized, 0);
rb_define_method(Quat_class, "is_normalized", &rb_godot_quat_is_normalized, 0);
rb_define_method(Quat_class, "inverse", &rb_godot_quat_inverse, 0);
rb_define_method(Quat_class, "dot", &rb_godot_quat_dot, 1);
rb_define_method(Quat_class, "xform", &rb_godot_quat_xform, 1);
rb_define_method(Quat_class, "slerp", &rb_godot_quat_slerp, 2);
rb_define_method(Quat_class, "slerpni", &rb_godot_quat_slerpni, 2);
rb_define_method(Quat_class, "cubic_slerp", &rb_godot_quat_cubic_slerp, 4);
rb_define_method(Quat_class, "operator_multiply", &rb_godot_quat_operator_multiply, 1);
rb_define_method(Quat_class, "operator_add", &rb_godot_quat_operator_add, 1);
rb_define_method(Quat_class, "operator_subtract", &rb_godot_quat_operator_subtract, 1);
rb_define_method(Quat_class, "operator_divide", &rb_godot_quat_operator_divide, 1);
rb_define_method(Quat_class, "operator_equal", &rb_godot_quat_operator_equal, 1);
rb_define_method(Quat_class, "operator_neg", &rb_godot_quat_operator_neg, 0);
rb_define_singleton_method(Quat_class, "_finalize", &rb_godot_quat_finalize, 1);
rb_define_method(Quat_class, "_type", &rb_godot_quat_type, 0);
rb_define_alias(Quat_class, "*", "operator_multiply");
rb_define_alias(Quat_class, "+", "operator_add");
rb_define_alias(Quat_class, "-", "operator_subtract");
rb_define_alias(Quat_class, "/", "operator_divide");
rb_define_alias(Quat_class, "==", "operator_equal");
rb_define_alias(Quat_class, "-@", "operator_neg");
rb_define_method(Rect2_class, "_initialize_with_position_and_size", &rb_godot_rect2_initialize_with_position_and_size, 2);
rb_define_method(Rect2_class, "_initialize", &rb_godot_rect2_initialize, 4);
rb_define_method(Rect2_class, "as_string", &rb_godot_rect2_as_string, 0);
rb_define_method(Rect2_class, "get_area", &rb_godot_rect2_get_area, 0);
rb_define_method(Rect2_class, "intersects", &rb_godot_rect2_intersects, 1);
rb_define_method(Rect2_class, "encloses", &rb_godot_rect2_encloses, 1);
rb_define_method(Rect2_class, "has_no_area", &rb_godot_rect2_has_no_area, 0);
rb_define_method(Rect2_class, "clip", &rb_godot_rect2_clip, 1);
rb_define_method(Rect2_class, "merge", &rb_godot_rect2_merge, 1);
rb_define_method(Rect2_class, "has_point", &rb_godot_rect2_has_point, 1);
rb_define_method(Rect2_class, "grow", &rb_godot_rect2_grow, 1);
rb_define_method(Rect2_class, "expand", &rb_godot_rect2_expand, 1);
rb_define_method(Rect2_class, "operator_equal", &rb_godot_rect2_operator_equal, 1);
rb_define_method(Rect2_class, "get_position", &rb_godot_rect2_get_position, 0);
rb_define_method(Rect2_class, "get_size", &rb_godot_rect2_get_size, 0);
rb_define_method(Rect2_class, "set_position", &rb_godot_rect2_set_position, 1);
rb_define_method(Rect2_class, "set_size", &rb_godot_rect2_set_size, 1);
rb_define_singleton_method(Rect2_class, "_finalize", &rb_godot_rect2_finalize, 1);
rb_define_method(Rect2_class, "_type", &rb_godot_rect2_type, 0);
rb_define_alias(Rect2_class, "==", "operator_equal");
rb_define_method(Transform_class, "_initialize_with_axis_origin", &rb_godot_transform_initialize_with_axis_origin, 4);
rb_define_method(Transform_class, "_initialize", &rb_godot_transform_initialize, 2);
rb_define_method(Transform_class, "get_basis", &rb_godot_transform_get_basis, 0);
rb_define_method(Transform_class, "set_basis", &rb_godot_transform_set_basis, 1);
rb_define_method(Transform_class, "get_origin", &rb_godot_transform_get_origin, 0);
rb_define_method(Transform_class, "set_origin", &rb_godot_transform_set_origin, 1);
rb_define_method(Transform_class, "as_string", &rb_godot_transform_as_string, 0);
rb_define_method(Transform_class, "inverse", &rb_godot_transform_inverse, 0);
rb_define_method(Transform_class, "affine_inverse", &rb_godot_transform_affine_inverse, 0);
rb_define_method(Transform_class, "orthonormalized", &rb_godot_transform_orthonormalized, 0);
rb_define_method(Transform_class, "rotated", &rb_godot_transform_rotated, 2);
rb_define_method(Transform_class, "scaled", &rb_godot_transform_scaled, 1);
rb_define_method(Transform_class, "translated", &rb_godot_transform_translated, 1);
rb_define_method(Transform_class, "looking_at", &rb_godot_transform_looking_at, 2);
rb_define_method(Transform_class, "xform_plane", &rb_godot_transform_xform_plane, 1);
rb_define_method(Transform_class, "xform_inv_plane", &rb_godot_transform_xform_inv_plane, 1);
rb_define_method(Transform_class, "operator_equal", &rb_godot_transform_operator_equal, 1);
rb_define_method(Transform_class, "operator_multiply", &rb_godot_transform_operator_multiply, 1);
rb_define_method(Transform_class, "xform_vector3", &rb_godot_transform_xform_vector3, 1);
rb_define_method(Transform_class, "xform_inv_vector3", &rb_godot_transform_xform_inv_vector3, 1);
rb_define_method(Transform_class, "xform_aabb", &rb_godot_transform_xform_aabb, 1);
rb_define_method(Transform_class, "xform_inv_aabb", &rb_godot_transform_xform_inv_aabb, 1);
rb_define_singleton_method(Transform_class, "_finalize", &rb_godot_transform_finalize, 1);
rb_define_method(Transform_class, "_type", &rb_godot_transform_type, 0);
rb_define_alias(Transform_class, "==", "operator_equal");
rb_define_alias(Transform_class, "*", "operator_multiply");
rb_define_method(Transform2D_class, "_initialize", &rb_godot_transform2d_initialize, 2);
rb_define_method(Transform2D_class, "_initialize_axis_origin", &rb_godot_transform2d_initialize_axis_origin, 3);
rb_define_method(Transform2D_class, "as_string", &rb_godot_transform2d_as_string, 0);
rb_define_method(Transform2D_class, "inverse", &rb_godot_transform2d_inverse, 0);
rb_define_method(Transform2D_class, "affine_inverse", &rb_godot_transform2d_affine_inverse, 0);
rb_define_method(Transform2D_class, "get_rotation", &rb_godot_transform2d_get_rotation, 0);
rb_define_method(Transform2D_class, "get_origin", &rb_godot_transform2d_get_origin, 0);
rb_define_method(Transform2D_class, "get_scale", &rb_godot_transform2d_get_scale, 0);
rb_define_method(Transform2D_class, "orthonormalized", &rb_godot_transform2d_orthonormalized, 0);
rb_define_method(Transform2D_class, "rotated", &rb_godot_transform2d_rotated, 1);
rb_define_method(Transform2D_class, "scaled", &rb_godot_transform2d_scaled, 1);
rb_define_method(Transform2D_class, "translated", &rb_godot_transform2d_translated, 1);
rb_define_method(Transform2D_class, "xform_vector2", &rb_godot_transform2d_xform_vector2, 1);
rb_define_method(Transform2D_class, "xform_inv_vector2", &rb_godot_transform2d_xform_inv_vector2, 1);
rb_define_method(Transform2D_class, "basis_xform_vector2", &rb_godot_transform2d_basis_xform_vector2, 1);
rb_define_method(Transform2D_class, "basis_xform_inv_vector2", &rb_godot_transform2d_basis_xform_inv_vector2, 1);
rb_define_method(Transform2D_class, "interpolate_with", &rb_godot_transform2d_interpolate_with, 2);
rb_define_method(Transform2D_class, "operator_equal", &rb_godot_transform2d_operator_equal, 1);
rb_define_method(Transform2D_class, "operator_multiply", &rb_godot_transform2d_operator_multiply, 1);
rb_define_method(Transform2D_class, "xform_rect2", &rb_godot_transform2d_xform_rect2, 1);
rb_define_method(Transform2D_class, "xform_inv_rect2", &rb_godot_transform2d_xform_inv_rect2, 1);
rb_define_singleton_method(Transform2D_class, "_finalize", &rb_godot_transform2d_finalize, 1);
rb_define_method(Transform2D_class, "_type", &rb_godot_transform2d_type, 0);
rb_define_alias(Transform2D_class, "==", "operator_equal");
rb_define_alias(Transform2D_class, "*", "operator_multiply");
rb_define_method(Vector2_class, "_initialize", &rb_godot_vector2_initialize, 2);
rb_define_method(Vector2_class, "as_string", &rb_godot_vector2_as_string, 0);
rb_define_method(Vector2_class, "normalized", &rb_godot_vector2_normalized, 0);
rb_define_method(Vector2_class, "length", &rb_godot_vector2_length, 0);
rb_define_method(Vector2_class, "angle", &rb_godot_vector2_angle, 0);
rb_define_method(Vector2_class, "length_squared", &rb_godot_vector2_length_squared, 0);
rb_define_method(Vector2_class, "is_normalized", &rb_godot_vector2_is_normalized, 0);
rb_define_method(Vector2_class, "distance_to", &rb_godot_vector2_distance_to, 1);
rb_define_method(Vector2_class, "distance_squared_to", &rb_godot_vector2_distance_squared_to, 1);
rb_define_method(Vector2_class, "angle_to", &rb_godot_vector2_angle_to, 1);
rb_define_method(Vector2_class, "angle_to_point", &rb_godot_vector2_angle_to_point, 1);
rb_define_method(Vector2_class, "linear_interpolate", &rb_godot_vector2_linear_interpolate, 2);
rb_define_method(Vector2_class, "cubic_interpolate", &rb_godot_vector2_cubic_interpolate, 4);
rb_define_method(Vector2_class, "rotated", &rb_godot_vector2_rotated, 1);
rb_define_method(Vector2_class, "tangent", &rb_godot_vector2_tangent, 0);
rb_define_method(Vector2_class, "floor", &rb_godot_vector2_floor, 0);
rb_define_method(Vector2_class, "snapped", &rb_godot_vector2_snapped, 1);
rb_define_method(Vector2_class, "aspect", &rb_godot_vector2_aspect, 0);
rb_define_method(Vector2_class, "dot", &rb_godot_vector2_dot, 1);
rb_define_method(Vector2_class, "slide", &rb_godot_vector2_slide, 1);
rb_define_method(Vector2_class, "bounce", &rb_godot_vector2_bounce, 1);
rb_define_method(Vector2_class, "reflect", &rb_godot_vector2_reflect, 1);
rb_define_method(Vector2_class, "abs", &rb_godot_vector2_abs, 0);
rb_define_method(Vector2_class, "clamped", &rb_godot_vector2_clamped, 1);
rb_define_method(Vector2_class, "operator_add", &rb_godot_vector2_operator_add, 1);
rb_define_method(Vector2_class, "operator_subtract", &rb_godot_vector2_operator_subtract, 1);
rb_define_method(Vector2_class, "operator_multiply_vector", &rb_godot_vector2_operator_multiply_vector, 1);
rb_define_method(Vector2_class, "operator_multiply_scalar", &rb_godot_vector2_operator_multiply_scalar, 1);
rb_define_method(Vector2_class, "operator_divide_vector", &rb_godot_vector2_operator_divide_vector, 1);
rb_define_method(Vector2_class, "operator_divide_scalar", &rb_godot_vector2_operator_divide_scalar, 1);
rb_define_method(Vector2_class, "operator_equal", &rb_godot_vector2_operator_equal, 1);
rb_define_method(Vector2_class, "operator_less", &rb_godot_vector2_operator_less, 1);
rb_define_method(Vector2_class, "operator_neg", &rb_godot_vector2_operator_neg, 0);
rb_define_method(Vector2_class, "set_x", &rb_godot_vector2_set_x, 1);
rb_define_method(Vector2_class, "set_y", &rb_godot_vector2_set_y, 1);
rb_define_method(Vector2_class, "get_x", &rb_godot_vector2_get_x, 0);
rb_define_method(Vector2_class, "get_y", &rb_godot_vector2_get_y, 0);
rb_define_singleton_method(Vector2_class, "_finalize", &rb_godot_vector2_finalize, 1);
rb_define_method(Vector2_class, "_type", &rb_godot_vector2_type, 0);
rb_define_alias(Vector2_class, "+", "operator_add");
rb_define_alias(Vector2_class, "-", "operator_subtract");
rb_define_alias(Vector2_class, "==", "operator_equal");
rb_define_alias(Vector2_class, "<", "operator_less");
rb_define_alias(Vector2_class, "-@", "operator_neg");
rb_define_method(Vector3_class, "_initialize", &rb_godot_vector3_initialize, 3);
rb_define_method(Vector3_class, "as_string", &rb_godot_vector3_as_string, 0);
rb_define_method(Vector3_class, "min_axis", &rb_godot_vector3_min_axis, 0);
rb_define_method(Vector3_class, "max_axis", &rb_godot_vector3_max_axis, 0);
rb_define_method(Vector3_class, "length", &rb_godot_vector3_length, 0);
rb_define_method(Vector3_class, "length_squared", &rb_godot_vector3_length_squared, 0);
rb_define_method(Vector3_class, "is_normalized", &rb_godot_vector3_is_normalized, 0);
rb_define_method(Vector3_class, "normalized", &rb_godot_vector3_normalized, 0);
rb_define_method(Vector3_class, "inverse", &rb_godot_vector3_inverse, 0);
rb_define_method(Vector3_class, "snapped", &rb_godot_vector3_snapped, 1);
rb_define_method(Vector3_class, "rotated", &rb_godot_vector3_rotated, 2);
rb_define_method(Vector3_class, "linear_interpolate", &rb_godot_vector3_linear_interpolate, 2);
rb_define_method(Vector3_class, "cubic_interpolate", &rb_godot_vector3_cubic_interpolate, 4);
rb_define_method(Vector3_class, "dot", &rb_godot_vector3_dot, 1);
rb_define_method(Vector3_class, "cross", &rb_godot_vector3_cross, 1);
rb_define_method(Vector3_class, "outer", &rb_godot_vector3_outer, 1);
rb_define_method(Vector3_class, "to_diagonal_matrix", &rb_godot_vector3_to_diagonal_matrix, 0);
rb_define_method(Vector3_class, "abs", &rb_godot_vector3_abs, 0);
rb_define_method(Vector3_class, "floor", &rb_godot_vector3_floor, 0);
rb_define_method(Vector3_class, "ceil", &rb_godot_vector3_ceil, 0);
rb_define_method(Vector3_class, "distance_to", &rb_godot_vector3_distance_to, 1);
rb_define_method(Vector3_class, "distance_squared_to", &rb_godot_vector3_distance_squared_to, 1);
rb_define_method(Vector3_class, "angle_to", &rb_godot_vector3_angle_to, 1);
rb_define_method(Vector3_class, "slide", &rb_godot_vector3_slide, 1);
rb_define_method(Vector3_class, "bounce", &rb_godot_vector3_bounce, 1);
rb_define_method(Vector3_class, "reflect", &rb_godot_vector3_reflect, 1);
rb_define_method(Vector3_class, "operator_add", &rb_godot_vector3_operator_add, 1);
rb_define_method(Vector3_class, "operator_subtract", &rb_godot_vector3_operator_subtract, 1);
rb_define_method(Vector3_class, "operator_multiply_vector", &rb_godot_vector3_operator_multiply_vector, 1);
rb_define_method(Vector3_class, "operator_multiply_scalar", &rb_godot_vector3_operator_multiply_scalar, 1);
rb_define_method(Vector3_class, "operator_divide_vector", &rb_godot_vector3_operator_divide_vector, 1);
rb_define_method(Vector3_class, "operator_divide_scalar", &rb_godot_vector3_operator_divide_scalar, 1);
rb_define_method(Vector3_class, "operator_equal", &rb_godot_vector3_operator_equal, 1);
rb_define_method(Vector3_class, "operator_less", &rb_godot_vector3_operator_less, 1);
rb_define_method(Vector3_class, "operator_neg", &rb_godot_vector3_operator_neg, 0);
rb_define_method(Vector3_class, "set_axis", &rb_godot_vector3_set_axis, 2);
rb_define_method(Vector3_class, "get_axis", &rb_godot_vector3_get_axis, 1);
rb_define_singleton_method(Vector3_class, "_finalize", &rb_godot_vector3_finalize, 1);
rb_define_method(Vector3_class, "_type", &rb_godot_vector3_type, 0);
rb_define_alias(Vector3_class, "+", "operator_add");
rb_define_alias(Vector3_class, "-", "operator_subtract");
rb_define_alias(Vector3_class, "==", "operator_equal");
rb_define_alias(Vector3_class, "<", "operator_less");
rb_define_alias(Vector3_class, "-@", "operator_neg");
rb_define_method(Array_class, "_initialize", &rb_godot_array_initialize, 1);
rb_define_method(Array_class, "set", &rb_godot_array_set, 2);
rb_define_method(Array_class, "get", &rb_godot_array_get, 1);
rb_define_method(Array_class, "operator_index", &rb_godot_array_operator_index, 1);
rb_define_method(Array_class, "operator_index_const", &rb_godot_array_operator_index_const, 1);
rb_define_method(Array_class, "append", &rb_godot_array_append, 1);
rb_define_method(Array_class, "clear", &rb_godot_array_clear, 0);
rb_define_method(Array_class, "count", &rb_godot_array_count, 1);
rb_define_method(Array_class, "empty", &rb_godot_array_empty, 0);
rb_define_method(Array_class, "erase", &rb_godot_array_erase, 1);
rb_define_method(Array_class, "front", &rb_godot_array_front, 0);
rb_define_method(Array_class, "back", &rb_godot_array_back, 0);
rb_define_method(Array_class, "find", &rb_godot_array_find, 2);
rb_define_method(Array_class, "find_last", &rb_godot_array_find_last, 1);
rb_define_method(Array_class, "has", &rb_godot_array_has, 1);
rb_define_method(Array_class, "insert", &rb_godot_array_insert, 2);
rb_define_method(Array_class, "invert", &rb_godot_array_invert, 0);
rb_define_method(Array_class, "pop_back", &rb_godot_array_pop_back, 0);
rb_define_method(Array_class, "pop_front", &rb_godot_array_pop_front, 0);
rb_define_method(Array_class, "push_back", &rb_godot_array_push_back, 1);
rb_define_method(Array_class, "push_front", &rb_godot_array_push_front, 1);
rb_define_method(Array_class, "remove", &rb_godot_array_remove, 1);
rb_define_method(Array_class, "resize", &rb_godot_array_resize, 1);
rb_define_method(Array_class, "rfind", &rb_godot_array_rfind, 2);
rb_define_method(Array_class, "size", &rb_godot_array_size, 0);
rb_define_method(Array_class, "sort", &rb_godot_array_sort, 0);
rb_define_method(Array_class, "bsearch", &rb_godot_array_bsearch, 2);
rb_define_method(Array_class, "destroy", &rb_godot_array_destroy, 0);
rb_define_singleton_method(Array_class, "_finalize", &rb_godot_array_finalize, 0);
rb_define_method(Array_class, "_type", &rb_godot_array_type, 0);
rb_define_method(Array_class, "to_a", &rb_godot_array_to_a, 0);
rb_define_alias(Array_class, "[]", "operator_index");
rb_define_method(Dictionary_class, "_initialize", &rb_godot_dictionary_initialize, 1);
rb_define_method(Dictionary_class, "destroy", &rb_godot_dictionary_destroy, 0);
rb_define_method(Dictionary_class, "size", &rb_godot_dictionary_size, 0);
rb_define_method(Dictionary_class, "empty", &rb_godot_dictionary_empty, 0);
rb_define_method(Dictionary_class, "clear", &rb_godot_dictionary_clear, 0);
rb_define_method(Dictionary_class, "has", &rb_godot_dictionary_has, 1);
rb_define_method(Dictionary_class, "has_all", &rb_godot_dictionary_has_all, 1);
rb_define_method(Dictionary_class, "erase", &rb_godot_dictionary_erase, 1);
rb_define_method(Dictionary_class, "keys", &rb_godot_dictionary_keys, 0);
rb_define_method(Dictionary_class, "values", &rb_godot_dictionary_values, 0);
rb_define_method(Dictionary_class, "get", &rb_godot_dictionary_get, 1);
rb_define_method(Dictionary_class, "set", &rb_godot_dictionary_set, 2);
rb_define_method(Dictionary_class, "operator_index", &rb_godot_dictionary_operator_index, 1);
rb_define_method(Dictionary_class, "operator_index_const", &rb_godot_dictionary_operator_index_const, 1);
rb_define_method(Dictionary_class, "next", &rb_godot_dictionary_next, 1);
rb_define_method(Dictionary_class, "operator_equal", &rb_godot_dictionary_operator_equal, 1);
rb_define_method(Dictionary_class, "to_json", &rb_godot_dictionary_to_json, 0);
rb_define_singleton_method(Dictionary_class, "_finalize", &rb_godot_dictionary_finalize, 0);
rb_define_method(Dictionary_class, "_type", &rb_godot_dictionary_type, 0);
rb_define_method(Dictionary_class, "to_h", &rb_godot_dictionary_to_h, 0);
rb_define_alias(Dictionary_class, "[]", "operator_index");
rb_define_alias(Dictionary_class, "==", "operator_equal");
rb_define_method(NodePath_class, "_initialize", &rb_godot_node_path_initialize, 1);
rb_define_method(NodePath_class, "destroy", &rb_godot_node_path_destroy, 0);
rb_define_method(NodePath_class, "as_string", &rb_godot_node_path_as_string, 0);
rb_define_method(NodePath_class, "is_absolute", &rb_godot_node_path_is_absolute, 0);
rb_define_method(NodePath_class, "get_name_count", &rb_godot_node_path_get_name_count, 0);
rb_define_method(NodePath_class, "get_name", &rb_godot_node_path_get_name, 1);
rb_define_method(NodePath_class, "get_subname_count", &rb_godot_node_path_get_subname_count, 0);
rb_define_method(NodePath_class, "get_subname", &rb_godot_node_path_get_subname, 1);
rb_define_method(NodePath_class, "get_concatenated_subnames", &rb_godot_node_path_get_concatenated_subnames, 0);
rb_define_method(NodePath_class, "is_empty", &rb_godot_node_path_is_empty, 0);
rb_define_method(NodePath_class, "operator_equal", &rb_godot_node_path_operator_equal, 1);
rb_define_singleton_method(NodePath_class, "_finalize", &rb_godot_node_path_finalize, 0);
rb_define_method(NodePath_class, "_type", &rb_godot_node_path_type, 0);
rb_define_alias(NodePath_class, "==", "operator_equal");
rb_define_singleton_method(Object_class, "_finalize", &rb_godot_object_finalize, 0);
rb_define_method(Object_class, "_type", &rb_godot_object_type, 0);

rb_define_method(PoolStringArray_class, "_initialize", &rb_godot_pool_string_array_initialize, 1);
rb_define_method(PoolStringArray_class, "append", &rb_godot_pool_string_array_append, 1);
rb_define_method(PoolStringArray_class, "append_array", &rb_godot_pool_string_array_append_array, 1);
rb_define_method(PoolStringArray_class, "insert", &rb_godot_pool_string_array_insert, 2);
rb_define_method(PoolStringArray_class, "invert", &rb_godot_pool_string_array_invert, 0);
rb_define_method(PoolStringArray_class, "push_back", &rb_godot_pool_string_array_push_back, 1);
rb_define_method(PoolStringArray_class, "remove", &rb_godot_pool_string_array_remove, 1);
rb_define_method(PoolStringArray_class, "resize", &rb_godot_pool_string_array_resize, 1);
rb_define_method(PoolStringArray_class, "set", &rb_godot_pool_string_array_set, 2);
rb_define_method(PoolStringArray_class, "get", &rb_godot_pool_string_array_get, 1);
rb_define_method(PoolStringArray_class, "size", &rb_godot_pool_string_array_size, 0);
rb_define_method(PoolStringArray_class, "destroy", &rb_godot_pool_string_array_destroy, 0);
rb_define_singleton_method(PoolStringArray_class, "_finalize", &rb_godot_pool_string_array_finalize, 0);
rb_define_method(PoolStringArray_class, "_type", &rb_godot_pool_string_array_type, 0);

rb_define_method(String_class, "_initialize", &rb_godot_string_initialize, 1);
rb_define_method(String_class, "operator_index", &rb_godot_string_operator_index, 1);
rb_define_method(String_class, "operator_index_const", &rb_godot_string_operator_index_const, 1);
rb_define_method(String_class, "wide_str", &rb_godot_string_wide_str, 0);
rb_define_method(String_class, "operator_equal", &rb_godot_string_operator_equal, 1);
rb_define_method(String_class, "operator_less", &rb_godot_string_operator_less, 1);
rb_define_method(String_class, "operator_plus", &rb_godot_string_operator_plus, 1);
rb_define_method(String_class, "length", &rb_godot_string_length, 0);
rb_define_method(String_class, "casecmp_to", &rb_godot_string_casecmp_to, 1);
rb_define_method(String_class, "nocasecmp_to", &rb_godot_string_nocasecmp_to, 1);
rb_define_method(String_class, "naturalnocasecmp_to", &rb_godot_string_naturalnocasecmp_to, 1);
rb_define_method(String_class, "begins_with", &rb_godot_string_begins_with, 1);
rb_define_method(String_class, "bigrams", &rb_godot_string_bigrams, 0);
rb_define_method(String_class, "ends_with", &rb_godot_string_ends_with, 1);
rb_define_method(String_class, "find", &rb_godot_string_find, 1);
rb_define_method(String_class, "find_from", &rb_godot_string_find_from, 2);
rb_define_method(String_class, "findmk", &rb_godot_string_findmk, 1);
rb_define_method(String_class, "findmk_from", &rb_godot_string_findmk_from, 2);
rb_define_method(String_class, "findn", &rb_godot_string_findn, 1);
rb_define_method(String_class, "findn_from", &rb_godot_string_findn_from, 2);
rb_define_method(String_class, "find_last", &rb_godot_string_find_last, 1);
rb_define_method(String_class, "format", &rb_godot_string_format, 1);
rb_define_method(String_class, "hex_to_int", &rb_godot_string_hex_to_int, 0);
rb_define_method(String_class, "hex_to_int_without_prefix", &rb_godot_string_hex_to_int_without_prefix, 0);
rb_define_method(String_class, "insert", &rb_godot_string_insert, 2);
rb_define_method(String_class, "is_numeric", &rb_godot_string_is_numeric, 0);
rb_define_method(String_class, "is_subsequence_of", &rb_godot_string_is_subsequence_of, 1);
rb_define_method(String_class, "is_subsequence_ofi", &rb_godot_string_is_subsequence_ofi, 1);
rb_define_method(String_class, "lpad", &rb_godot_string_lpad, 1);
rb_define_method(String_class, "lpad_with_custom_character", &rb_godot_string_lpad_with_custom_character, 2);
rb_define_method(String_class, "match", &rb_godot_string_match, 1);
rb_define_method(String_class, "matchn", &rb_godot_string_matchn, 1);
rb_define_method(String_class, "pad_decimals", &rb_godot_string_pad_decimals, 1);
rb_define_method(String_class, "pad_zeros", &rb_godot_string_pad_zeros, 1);
rb_define_method(String_class, "replace_first", &rb_godot_string_replace_first, 2);
rb_define_method(String_class, "replace", &rb_godot_string_replace, 2);
rb_define_method(String_class, "replacen", &rb_godot_string_replacen, 2);
rb_define_method(String_class, "rfind", &rb_godot_string_rfind, 1);
rb_define_method(String_class, "rfindn", &rb_godot_string_rfindn, 1);
rb_define_method(String_class, "rfind_from", &rb_godot_string_rfind_from, 2);
rb_define_method(String_class, "rfindn_from", &rb_godot_string_rfindn_from, 2);
rb_define_method(String_class, "rpad", &rb_godot_string_rpad, 1);
rb_define_method(String_class, "rpad_with_custom_character", &rb_godot_string_rpad_with_custom_character, 2);
rb_define_method(String_class, "similarity", &rb_godot_string_similarity, 1);
rb_define_method(String_class, "substr", &rb_godot_string_substr, 2);
rb_define_method(String_class, "to_float", &rb_godot_string_to_float, 0);
rb_define_method(String_class, "to_int", &rb_godot_string_to_int, 0);
rb_define_method(String_class, "camelcase_to_underscore", &rb_godot_string_camelcase_to_underscore, 0);
rb_define_method(String_class, "camelcase_to_underscore_lowercased", &rb_godot_string_camelcase_to_underscore_lowercased, 0);
rb_define_method(String_class, "capitalize", &rb_godot_string_capitalize, 0);
rb_define_method(String_class, "get_slice_count", &rb_godot_string_get_slice_count, 1);
rb_define_method(String_class, "get_slice", &rb_godot_string_get_slice, 2);
rb_define_method(String_class, "split", &rb_godot_string_split, 1);
rb_define_method(String_class, "split_allow_empty", &rb_godot_string_split_allow_empty, 1);
rb_define_method(String_class, "split_floats", &rb_godot_string_split_floats, 1);
rb_define_method(String_class, "split_floats_allows_empty", &rb_godot_string_split_floats_allows_empty, 1);
rb_define_method(String_class, "split_floats_mk", &rb_godot_string_split_floats_mk, 1);
rb_define_method(String_class, "split_floats_mk_allows_empty", &rb_godot_string_split_floats_mk_allows_empty, 1);
rb_define_method(String_class, "split_ints", &rb_godot_string_split_ints, 1);
rb_define_method(String_class, "split_ints_allows_empty", &rb_godot_string_split_ints_allows_empty, 1);
rb_define_method(String_class, "split_ints_mk", &rb_godot_string_split_ints_mk, 1);
rb_define_method(String_class, "split_ints_mk_allows_empty", &rb_godot_string_split_ints_mk_allows_empty, 1);
rb_define_method(String_class, "split_spaces", &rb_godot_string_split_spaces, 0);
rb_define_method(String_class, "to_lower", &rb_godot_string_to_lower, 0);
rb_define_method(String_class, "to_upper", &rb_godot_string_to_upper, 0);
rb_define_method(String_class, "get_basename", &rb_godot_string_get_basename, 0);
rb_define_method(String_class, "get_extension", &rb_godot_string_get_extension, 0);
rb_define_method(String_class, "left", &rb_godot_string_left, 1);
rb_define_method(String_class, "ord_at", &rb_godot_string_ord_at, 1);
rb_define_method(String_class, "plus_file", &rb_godot_string_plus_file, 1);
rb_define_method(String_class, "right", &rb_godot_string_right, 1);
rb_define_method(String_class, "strip_edges", &rb_godot_string_strip_edges, 2);
rb_define_method(String_class, "strip_escapes", &rb_godot_string_strip_escapes, 0);
rb_define_method(String_class, "erase", &rb_godot_string_erase, 2);
rb_define_method(String_class, "md5_text", &rb_godot_string_md5_text, 0);
rb_define_method(String_class, "sha256_text", &rb_godot_string_sha256_text, 0);
rb_define_method(String_class, "empty", &rb_godot_string_empty, 0);
rb_define_method(String_class, "get_base_dir", &rb_godot_string_get_base_dir, 0);
rb_define_method(String_class, "get_file", &rb_godot_string_get_file, 0);
rb_define_method(String_class, "is_abs_path", &rb_godot_string_is_abs_path, 0);
rb_define_method(String_class, "is_rel_path", &rb_godot_string_is_rel_path, 0);
rb_define_method(String_class, "is_resource_file", &rb_godot_string_is_resource_file, 0);
rb_define_method(String_class, "path_to", &rb_godot_string_path_to, 1);
rb_define_method(String_class, "path_to_file", &rb_godot_string_path_to_file, 1);
rb_define_method(String_class, "simplify_path", &rb_godot_string_simplify_path, 0);
rb_define_method(String_class, "c_escape", &rb_godot_string_c_escape, 0);
rb_define_method(String_class, "c_escape_multiline", &rb_godot_string_c_escape_multiline, 0);
rb_define_method(String_class, "c_unescape", &rb_godot_string_c_unescape, 0);
rb_define_method(String_class, "http_escape", &rb_godot_string_http_escape, 0);
rb_define_method(String_class, "http_unescape", &rb_godot_string_http_unescape, 0);
rb_define_method(String_class, "json_escape", &rb_godot_string_json_escape, 0);
rb_define_method(String_class, "word_wrap", &rb_godot_string_word_wrap, 1);
rb_define_method(String_class, "xml_escape", &rb_godot_string_xml_escape, 0);
rb_define_method(String_class, "xml_escape_with_quotes", &rb_godot_string_xml_escape_with_quotes, 0);
rb_define_method(String_class, "xml_unescape", &rb_godot_string_xml_unescape, 0);
rb_define_method(String_class, "percent_decode", &rb_godot_string_percent_decode, 0);
rb_define_method(String_class, "percent_encode", &rb_godot_string_percent_encode, 0);
rb_define_method(String_class, "is_valid_float", &rb_godot_string_is_valid_float, 0);
rb_define_method(String_class, "is_valid_hex_number", &rb_godot_string_is_valid_hex_number, 1);
rb_define_method(String_class, "is_valid_html_color", &rb_godot_string_is_valid_html_color, 0);
rb_define_method(String_class, "is_valid_identifier", &rb_godot_string_is_valid_identifier, 0);
rb_define_method(String_class, "is_valid_integer", &rb_godot_string_is_valid_integer, 0);
rb_define_method(String_class, "is_valid_ip_address", &rb_godot_string_is_valid_ip_address, 0);
rb_define_method(String_class, "destroy", &rb_godot_string_destroy, 0);
rb_define_singleton_method(String_class, "_finalize", &rb_godot_string_finalize, 0);
rb_define_method(String_class, "_type", &rb_godot_string_type, 0);
rb_define_method(String_class, "to_s", &rb_godot_string_to_s, 0);
rb_define_alias(String_class, "[]", "operator_index");
rb_define_alias(String_class, "==", "operator_equal");
rb_define_alias(String_class, "<", "operator_less");
rb_define_alias(String_class, "+", "operator_plus");
}