}

void AudioDriverCoreAudio::finish() {

if (result != noErr) {

}

#ifdef OSX_ENABLED

#endif

if (mutex) {

memdelete(mutex);

mutex = NULL;

}

Error AudioDriverCoreAudio::capture_start() {

#endif

AudioDriverCoreAudio::AudioDriverCoreAudio() {

active = false;

mutex = NULL;

light_instance->light = p_light;

light_instance->light_ptr = storage->light_owner.getornull(p_light);

light_instance->self = light_instance_owner.make_rid(light_instance);

//printf("errnum: %x\n",status);

glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);

return canvas_light_shadow_owner.make_rid(cls);

}

GDScriptLanguage::singleton->lock->unlock();

#endif

}

//@TODO make thread safe

FileAccess *fa = FileAccess::open(p_path, FileAccess::READ);

ERR_FAIL_COND_V(!fa, ERR_CANT_OPEN);

FileAccessEncrypted *fae = memnew(FileAccessEncrypted);

ERR_FAIL_COND_V(!fae, ERR_CANT_OPEN);

Vector<uint8_t> key;

key.resize(32);

for (int i = 0; i < key.size(); i++) {

key.write[i] = script_encryption_key[i];

}

Error err = fae->open_and_parse(fa, key, FileAccessEncrypted::MODE_READ);

bytecode.resize(fae->get_len());

fae->get_buffer(bytecode.ptrw(), bytecode.size());

memdelete(fae);

} else {

bytecode = FileAccess::get_file_as_array(p_path);

}

ERR_FAIL_COND_V(bytecode.size() == 0, ERR_PARSE_ERROR);

path = p_path;

Error err = script->load_byte_code(p_path);

if (err != OK) {

ERR_FAIL_COND_V(err != OK, RES());

}

Error err = script->load_source_code(p_path);

if (err != OK) {

ERR_FAIL_COND_V(err != OK, RES());

}

return scriptres;

}

void ResourceFormatLoaderGDScript::get_recognized_extensions(List<String> *p_extensions) const {

p_extensions->push_back("gd");

int ret = _parse_expression(codegen, op, p_stack_level);

if (ret < 0) {

return ERR_PARSE_ERROR;

}

// compile the condition

int ret = _parse_expression(codegen, branch.compiled_pattern, p_stack_level);

if (ret < 0) {

return ERR_PARSE_ERROR;

}

Error err = _parse_block(codegen, branch.body, p_stack_level, p_break_addr, continue_addr);

if (err) {

return ERR_PARSE_ERROR;

}

codegen.opcodes.write[break_addr + 1] = codegen.opcodes.size();

} break;

case GDScriptParser::ControlFlowNode::CF_IF: {

cs_icalls_content.push_back("using System;\n"

"using System.Runtime.CompilerServices;\n"

"\n");

cs_icalls_content.push_back("namespace " BINDINGS_NAMESPACE "\n" OPEN_BLOCK);

cs_icalls_content.push_back(INDENT1 "internal static class " BINDINGS_CLASS_NATIVECALLS "\n" INDENT1 OPEN_BLOCK);

cs_icalls_content.push_back("using System;\n"

"using System.Runtime.CompilerServices;\n"

"\n");

cs_icalls_content.push_back("namespace " BINDINGS_NAMESPACE "\n" OPEN_BLOCK);

cs_icalls_content.push_back(INDENT1 "internal static class " BINDINGS_CLASS_NATIVECALLS_EDITOR "\n" INDENT1 OPEN_BLOCK);

output.push_back("using System;\n"); // IntPtr

if (itype.requires_collections)

output.push_back("\nnamespace " BINDINGS_NAMESPACE "\n" OPEN_BLOCK);

imethod.return_type.cname = Variant::get_type_name(return_info.type);

}

itype.requires_collections = true;

for (int i = 0; i < argc; i++) {

iarg.name = escape_csharp_keyword(snake_to_camel_case(iarg.name));

itype.requires_collections = true;

if (m && m->has_default_argument(i)) {

itype = TypeInterface();

itype.name = "Array";

itype.cname = itype.name;

itype.c_out = "\treturn memnew(Array(%1));\n";

itype.c_type = itype.name;

itype.c_type_in = itype.c_type + "*";

itype.c_type_out = itype.c_type + "*";

itype.cs_type = itype.proxy_name;

itype.cs_in = "%0." CS_SMETHOD_GETINSTANCE "()";

itype.im_type_in = "IntPtr";

itype.im_type_out = "IntPtr";

builtin_types.insert(itype.cname, itype);

itype = TypeInterface();

itype.name = "Dictionary";

itype.cname = itype.name;

itype.c_out = "\treturn memnew(Dictionary(%1));\n";

itype.c_type = itype.name;

itype.c_type_in = itype.c_type + "*";

itype.c_type_out = itype.c_type + "*";

itype.cs_type = itype.proxy_name;

itype.cs_in = "%0." CS_SMETHOD_GETINSTANCE "()";

itype.im_type_in = "IntPtr";

itype.im_type_out = "IntPtr";

builtin_types.insert(itype.cname, itype);

else

iarg.type.cname = Variant::get_type_name(pi.type);

r_itype.requires_collections = true;

if ((mi.default_arguments.size() - mi.arguments.size() + i) >= 0)

imethod.return_type.cname = Variant::get_type_name(mi.return_val.type);

}

r_itype.requires_collections = true;

if (r_itype.class_doc) {

}

void godot_register_collections_icalls() {

}

using System.Runtime.CompilerServices;

using System.Runtime.InteropServices;

{

class ArraySafeHandle : SafeHandle

{

using System.Runtime.CompilerServices;

using System.Runtime.InteropServices;

{

class DictionarySafeHandle : SafeHandle

{

using System;

namespace Godot

{

#define GODOTSHARP_DEFS_H

#define BINDINGS_NAMESPACE "Godot"

#define BINDINGS_GLOBAL_SCOPE_CLASS "GD"

#define BINDINGS_PTR_FIELD "ptr"

#define BINDINGS_NATIVE_NAME_FIELD "nativeName"

}

#define GODOT_API_CLASS(m_class) (GDMono::get_singleton()->get_core_api_assembly()->get_class(BINDINGS_NAMESPACE, #m_class))

void update_corlib_cache() {

CACHE_CLASS_AND_CHECK(Control, GODOT_API_CLASS(Control));

CACHE_CLASS_AND_CHECK(Spatial, GODOT_API_CLASS(Spatial));

CACHE_CLASS_AND_CHECK(WeakRef, GODOT_API_CLASS(WeakRef));

CACHE_CLASS_AND_CHECK(MarshalUtils, GODOT_API_CLASS(MarshalUtils));

#ifdef DEBUG_ENABLED

CACHE_FIELD_AND_CHECK(NodePath, ptr, CACHED_CLASS(NodePath)->get_field(BINDINGS_PTR_FIELD));

CACHE_FIELD_AND_CHECK(RID, ptr, CACHED_CLASS(RID)->get_field(BINDINGS_PTR_FIELD));

CACHE_METHOD_THUNK_AND_CHECK(MarshalUtils, IsArrayGenericType, (IsArrayGenericType)GODOT_API_CLASS(MarshalUtils)->get_method_thunk("IsArrayGenericType", 1));

CACHE_METHOD_THUNK_AND_CHECK(MarshalUtils, IsDictionaryGenericType, (IsDictionaryGenericType)GODOT_API_CLASS(MarshalUtils)->get_method_thunk("IsDictionaryGenericType", 1));

CACHE_METHOD_THUNK_AND_CHECK(SignalAwaiter, SignalCallback, (SignalAwaiter_SignalCallback)GODOT_API_CLASS(SignalAwaiter)->get_method_thunk("SignalCallback", 1));

code = pcre2_compile_16(p, pattern.length(), flags, &err, &offset, cctx);

if (!code) {

PCRE2_UCHAR16 buf[256];

pcre2_get_error_message_16(err, buf, 256);

code = pcre2_compile_32(p, pattern.length(), flags, &err, &offset, cctx);

if (!code) {

PCRE2_UCHAR32 buf[256];

pcre2_get_error_message_32(err, buf, 256);

if (res < 0) {

pcre2_match_data_free_32(match);

return NULL;

}

String apkfname = "main." + itos(version_code) + "." + get_package_name(package_name) + ".obb";

String fullpath = p_path.get_base_dir().plus_file(apkfname);

err = save_pack(p_preset, fullpath);

if (err != OK) {

EditorNode::add_io_error("Could not write expansion package file: " + apkfname);

return OK;

}