void FixedMaterial::set_parameter(Parameter p_parameter, const Variant& p_value) { ERR_FAIL_INDEX(p_parameter,PARAM_MAX); if ((p_parameter==PARAM_DIFFUSE || p_parameter==PARAM_SPECULAR || p_parameter==PARAM_EMISSION)) { if (p_value.get_type()!=Variant::COLOR) { ERR_EXPLAIN(String(_param_names[p_parameter])+" expects Color"); ERR_FAIL(); } } else { if (!p_value.is_num()) { ERR_EXPLAIN(String(_param_names[p_parameter])+" expects scalar"); ERR_FAIL(); } } ERR_FAIL_COND( (p_parameter==PARAM_DIFFUSE || p_parameter==PARAM_SPECULAR || p_parameter==PARAM_EMISSION) && p_value.get_type()!=Variant::COLOR ); ERR_FAIL_COND( p_parameter!=PARAM_SHADE_PARAM && p_parameter!=PARAM_DIFFUSE && p_parameter!=PARAM_DETAIL && p_parameter!=PARAM_SPECULAR && p_parameter!=PARAM_EMISSION && p_value.get_type()!=Variant::REAL && p_value.get_type()!=Variant::INT ); param[p_parameter]=p_value; VisualServer::get_singleton()->fixed_material_set_param(material,(VS::FixedMaterialParam)p_parameter,p_value); _change_notify(_full_param_names[p_parameter]); }
void Sample::_set_data(const Dictionary& p_data) { ERR_FAIL_COND(!p_data.has("packing")); String packing = p_data["packing"]; if (packing=="raw") { ERR_FAIL_COND( !p_data.has("stereo")); ERR_FAIL_COND( !p_data.has("format")); ERR_FAIL_COND( !p_data.has("length")); bool stereo=p_data["stereo"]; int length=p_data["length"]; Format fmt; String fmtstr=p_data["format"]; if (fmtstr=="pcm8") fmt=FORMAT_PCM8; else if (fmtstr=="pcm16") fmt=FORMAT_PCM16; else if (fmtstr=="ima_adpcm") fmt=FORMAT_IMA_ADPCM; else { ERR_EXPLAIN("Invalid format for sample: "+fmtstr); ERR_FAIL(); } ERR_FAIL_COND(!p_data.has("data")); create(fmt,stereo,length); set_data(p_data["data"]); } else { ERR_EXPLAIN("Invalid packing for sample data: "+packing); ERR_FAIL(); } }
void ConnectDialog::_add_bind() { if (cdbinds->params.size() >= VARIANT_ARG_MAX) return; Variant::Type vt = (Variant::Type)type_list->get_item_ID(type_list->get_selected()); Variant value; switch(vt) { case Variant::BOOL: value = false ; break; case Variant::INT: value = 0; break; case Variant::REAL: value = 0.0; break; case Variant::STRING: value = ""; break; case Variant::VECTOR2: value = Vector2(); break; case Variant::RECT2: value = Rect2(); break; case Variant::VECTOR3: value = Vector3(); break; case Variant::PLANE: value = Plane(); break; case Variant::QUAT: value = Quat(); break; case Variant::_AABB: value = AABB(); break; case Variant::MATRIX3: value = Matrix3(); break; case Variant::TRANSFORM: value = Transform(); break; case Variant::COLOR: value = Color(); break; case Variant::IMAGE: value = Image(); break; default: { ERR_FAIL(); } break; } ERR_FAIL_COND(value.get_type()==Variant::NIL); cdbinds->params.push_back(value); cdbinds->notify_changed(); }
void print_unhandled_exception(MonoObject *p_exc, bool p_recursion_caution) { mono_print_unhandled_exception(p_exc); #ifdef DEBUG_ENABLED if (!ScriptDebugger::get_singleton()) return; ScriptLanguage::StackInfo separator; separator.file = ""; separator.func = "--- " + RTR("End of inner exception stack trace") + " ---"; separator.line = 0; Vector<ScriptLanguage::StackInfo> si; String exc_msg = ""; while (p_exc != NULL) { GDMonoClass *st_klass = CACHED_CLASS(System_Diagnostics_StackTrace); MonoObject *stack_trace = mono_object_new(mono_domain_get(), st_klass->get_mono_ptr()); MonoBoolean need_file_info = true; void *ctor_args[2] = { p_exc, &need_file_info }; MonoObject *unexpected_exc = NULL; CACHED_METHOD(System_Diagnostics_StackTrace, ctor_Exception_bool)->invoke_raw(stack_trace, ctor_args, &unexpected_exc); if (unexpected_exc != NULL) { mono_print_unhandled_exception(unexpected_exc); if (p_recursion_caution) { // Called from CSharpLanguage::get_current_stack_info, // so printing an error here could result in endless recursion OS::get_singleton()->printerr("Mono: Method GDMonoUtils::print_unhandled_exception failed"); return; } else { ERR_FAIL(); } } Vector<ScriptLanguage::StackInfo> _si; if (stack_trace != NULL && !p_recursion_caution) { _si = CSharpLanguage::get_singleton()->stack_trace_get_info(stack_trace); for (int i = _si.size() - 1; i >= 0; i--) si.insert(0, _si[i]); } exc_msg += (exc_msg.length() > 0 ? " ---> " : "") + GDMonoUtils::get_exception_name_and_message(p_exc); GDMonoProperty *p_prop = GDMono::get_singleton()->get_class(mono_object_get_class(p_exc))->get_property("InnerException"); p_exc = p_prop != NULL ? p_prop->get_value(p_exc) : NULL; if (p_exc != NULL) si.insert(0, separator); } String file = si.size() ? si[0].file : __FILE__; String func = si.size() ? si[0].func : FUNCTION_STR; int line = si.size() ? si[0].line : __LINE__; String error_msg = "Unhandled exception"; ScriptDebugger::get_singleton()->send_error(func, file, line, error_msg, exc_msg, ERR_HANDLER_ERROR, si); #endif }
void Spatial::look_at(const Vector3 &p_target, const Vector3 &p_up_normal) { Transform lookat; lookat.origin = get_global_transform().origin; if (lookat.origin == p_target) { ERR_EXPLAIN("Node origin and target are in the same position, look_at() failed"); ERR_FAIL(); } if (p_up_normal.cross(p_target - lookat.origin) == Vector3()) { ERR_EXPLAIN("Up vector and direction between node origin and target are aligned, look_at() failed"); ERR_FAIL(); } lookat = lookat.looking_at(p_target, p_up_normal); set_global_transform(lookat); }
static void _parse_hex(const String& p_string, int p_start, uint8_t* p_dst) { uint16_t ret = 0; for (int i=p_start; i<p_start + 4; i++) { if (i >= p_string.length()) { break; }; int n = 0; CharType c = p_string[i]; if (c >= '0' && c <= '9') { n = c - '0'; } else if (c >= 'a' && c <= 'f') { n = 10 + (c - 'a'); } else if (c >= 'A' && c <= 'F') { n = 10 + (c - 'A'); } else if (c == ':') { break; } else { ERR_EXPLAIN("Invalid character in ipv6 address: " + p_string); ERR_FAIL(); }; ret = ret << 4; ret += n; }; p_dst[0] = ret >> 8; p_dst[1] = ret & 0xff; };
void Object::disconnect(const StringName& p_signal, Object *p_to_object, const StringName& p_to_method) { ERR_FAIL_NULL(p_to_object); Signal *s = signal_map.getptr(p_signal); if (!s) { ERR_EXPLAIN("Nonexistent signal: "+p_signal); ERR_FAIL_COND(!s); } if (s->lock>0) { ERR_EXPLAIN("Attempt to disconnect signal '"+p_signal+"' while emitting (locks: "+itos(s->lock)+")"); ERR_FAIL_COND(s->lock>0); } Signal::Target target(p_to_object->get_instance_ID(),p_to_method); if (!s->slot_map.has(target)) { ERR_EXPLAIN("Disconnecting nonexistent signal '"+p_signal+"', slot: "+itos(target._id)+":"+target.method); ERR_FAIL(); } p_to_object->connections.erase(s->slot_map[target].cE); s->slot_map.erase(target); if (s->slot_map.empty() && ObjectTypeDB::has_signal(get_type_name(),p_signal )) { //not user signal, delete signal_map.erase(p_signal); } }
void NativeScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const { script->get_script_property_list(p_properties); NativeScriptDesc *script_data = GET_SCRIPT_DESC(); while (script_data) { Map<StringName, NativeScriptDesc::Method>::Element *E = script_data->methods.find("_get_property_list"); if (E) { godot_variant result; result = E->get().method.method((godot_object *)owner, E->get().method.method_data, userdata, 0, NULL); Variant res = *(Variant *)&result; godot_variant_destroy(&result); if (res.get_type() != Variant::ARRAY) { ERR_EXPLAIN("_get_property_list must return an array of dictionaries"); ERR_FAIL(); } Array arr = res; for (int i = 0; i < arr.size(); i++) { Dictionary d = arr[i]; ERR_CONTINUE(!d.has("name")); ERR_CONTINUE(!d.has("type")); PropertyInfo info; info.type = Variant::Type(d["type"].operator int64_t()); ERR_CONTINUE(info.type < 0 || info.type >= Variant::VARIANT_MAX); info.name = d["name"]; ERR_CONTINUE(info.name == ""); if (d.has("hint")) { info.hint = PropertyHint(d["hint"].operator int64_t()); } if (d.has("hint_string")) { info.hint_string = d["hint_string"]; } if (d.has("usage")) { info.usage = d["usage"]; } p_properties->push_back(info); } } script_data = script_data->base_data; } return; }
void Object::call_multilevel(const StringName& p_name, VARIANT_ARG_DECLARE) { #if 0 if (p_name==CoreStringNames::get_singleton()->_free) { #ifdef DEBUG_ENABLED if (cast_to<Reference>()) { ERR_EXPLAIN("Can't 'free' a reference."); ERR_FAIL(); return; } #endif //must be here, must be before everything, memdelete(this); return; } VARIANT_ARGPTRS; int argc=0; for(int i=0;i<VARIANT_ARG_MAX;i++) { if (argptr[i]->get_type()==Variant::NIL) break; argc++; } Variant::CallError error; if (script_instance) { script_instance->call(p_name,argptr,argc,error); _test_call_error(p_name,error); } MethodBind *method=ObjectTypeDB::get_method(get_type_name(),p_name); if (method) { method->call(this,argptr,argc,error); _test_call_error(p_name,error); } #else VARIANT_ARGPTRS; int argc=0; for(int i=0;i<VARIANT_ARG_MAX;i++) { if (argptr[i]->get_type()==Variant::NIL) break; argc++; } //Variant::CallError error; call_multilevel(p_name,argptr,argc); #endif }
void CanvasItem::draw_line(const Point2& p_from, const Point2& p_to,const Color& p_color,float p_width) { if (!drawing) { ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); ERR_FAIL(); } VisualServer::get_singleton()->canvas_item_add_line(canvas_item,p_from,p_to,p_color,p_width); }
void CanvasItem::draw_set_transform_matrix(const Transform2D &p_matrix) { if (!drawing) { ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); ERR_FAIL(); } VisualServer::get_singleton()->canvas_item_add_set_transform(canvas_item, p_matrix); }
void CanvasItem::draw_circle(const Point2 &p_pos, float p_radius, const Color &p_color) { if (!drawing) { ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); ERR_FAIL(); } VisualServer::get_singleton()->canvas_item_add_circle(canvas_item, p_pos, p_radius, p_color); }
void CanvasItem::draw_multiline_colors(const Vector<Point2> &p_points, const Vector<Color> &p_colors, float p_width, bool p_antialiased) { if (!drawing) { ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); ERR_FAIL(); } VisualServer::get_singleton()->canvas_item_add_multiline(canvas_item, p_points, p_colors, p_width, p_antialiased); }
void CanvasItem::draw_texture_rect_region(const Ref<Texture>& p_texture,const Rect2& p_rect, const Rect2& p_src_rect,const Color& p_modulate, bool p_transpose) { if (!drawing) { ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); ERR_FAIL(); } ERR_FAIL_COND(p_texture.is_null()); p_texture->draw_rect_region(canvas_item,p_rect,p_src_rect,p_modulate,p_transpose); }
void CPSampleManagerImpl::get_chunk(CPSample_ID p_id,int32_t p_index,void *p_data,int p_data_len) { SampleData *sd=_getsd(p_id); #ifdef DEBUG_ENABLED ERR_FAIL_COND(!valid.has(sd)); #endif ERR_FAIL(); }
void AudioDriverXAudio2::start() { active = true; HRESULT hr = source_voice->Start(0); if (hr != S_OK) { ERR_EXPLAIN("XAudio2 start error " + itos(hr)); ERR_FAIL(); } };
void Object::call_multilevel(const StringName& p_method,const Variant** p_args,int p_argcount) { if (p_method==CoreStringNames::get_singleton()->_free) { #ifdef DEBUG_ENABLED if (cast_to<Reference>()) { ERR_EXPLAIN("Can't 'free' a reference."); ERR_FAIL(); return; } if (_lock_index.get()>1) { ERR_EXPLAIN("Object is locked and can't be freed."); ERR_FAIL(); return; } #endif //must be here, must be before everything, memdelete(this); return; } //Variant ret; OBJ_DEBUG_LOCK Variant::CallError error; if (script_instance) { script_instance->call_multilevel(p_method,p_args,p_argcount); //_test_call_error(p_method,error); } MethodBind *method=ObjectTypeDB::get_method(get_type_name(),p_method); if (method) { method->call(this,p_args,p_argcount,error); _test_call_error(p_method,error); } }
void CanvasItem::draw_style_box(const Ref<StyleBox> &p_style_box, const Rect2 &p_rect) { if (!drawing) { ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); ERR_FAIL(); } ERR_FAIL_COND(p_style_box.is_null()); p_style_box->draw(canvas_item, p_rect); }
void CanvasItem::draw_string(const Ref<Font> &p_font, const Point2 &p_pos, const String &p_text, const Color &p_modulate, int p_clip_w) { if (!drawing) { ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); ERR_FAIL(); } ERR_FAIL_COND(p_font.is_null()); p_font->draw(canvas_item, p_pos, p_text, p_modulate, p_clip_w); }
void CanvasItem::draw_rect(const Rect2& p_rect, const Color& p_color) { if (!drawing) { ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); ERR_FAIL(); } VisualServer::get_singleton()->canvas_item_add_rect(canvas_item,p_rect,p_color); }
void EditorImportPlugin::import_dialog(const String& p_from) { if (get_script_instance() && get_script_instance()->has_method("import_dialog")) { get_script_instance()->call("import_dialog",p_from); return; } ERR_FAIL(); }
void GodotSharpEditor::_menu_option_pressed(int p_id) { switch (p_id) { case MENU_CREATE_SLN: { _create_project_solution(); } break; default: ERR_FAIL(); } }
void GDAPI godot_pluginscript_register_language(const godot_pluginscript_language_desc *language_desc) { Error ret = _check_language_desc(language_desc); if (ret) { ERR_FAIL(); } PluginScriptLanguage *language = memnew(PluginScriptLanguage(language_desc)); ScriptServer::register_language(language); ResourceLoader::add_resource_format_loader(language->get_resource_loader()); ResourceSaver::add_resource_format_saver(language->get_resource_saver()); pluginscript_languages.push_back(language); }
void CanvasItem::draw_texture(const Ref<Texture>& p_texture,const Point2& p_pos) { if (!drawing) { ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); ERR_FAIL(); } ERR_FAIL_COND(p_texture.is_null()); p_texture->draw(canvas_item,p_pos); }
void CanvasItem::draw_set_transform(const Point2& p_offset, float p_rot, const Size2& p_scale) { if (!drawing) { ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); ERR_FAIL(); } Matrix32 xform(p_rot,p_offset); xform.scale_basis(p_scale); VisualServer::get_singleton()->canvas_item_set_transform(canvas_item,xform); }
void CanvasItem::draw_primitive(const Vector<Point2>& p_points, const Vector<Color>& p_colors,const Vector<Point2>& p_uvs, Ref<Texture> p_texture,float p_width) { if (!drawing) { ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); ERR_FAIL(); } RID rid = p_texture.is_valid() ? p_texture->get_rid() : RID(); VisualServer::get_singleton()->canvas_item_add_primitive(canvas_item,p_points,p_colors,p_uvs,rid,p_width); }
void CanvasItem::draw_polygon(const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, Ref<Texture> p_texture, const Ref<Texture> &p_normal_map, bool p_antialiased) { if (!drawing) { ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); ERR_FAIL(); } RID rid = p_texture.is_valid() ? p_texture->get_rid() : RID(); RID rid_normal = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID(); VisualServer::get_singleton()->canvas_item_add_polygon(canvas_item, p_points, p_colors, p_uvs, rid, rid_normal, p_antialiased); }
void IP_Unix::get_local_addresses(List<IP_Address> *r_addresses) const { ULONG buf_size = 1024; IP_ADAPTER_ADDRESSES* addrs; while (true) { addrs = (IP_ADAPTER_ADDRESSES*)memalloc(buf_size); int err = GetAdaptersAddresses(AF_INET, GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_FRIENDLY_NAME, NULL, addrs, &buf_size); if (err == NO_ERROR) { break; }; memfree(addrs); if (err == ERROR_BUFFER_OVERFLOW) { continue; // will go back and alloc the right size }; ERR_EXPLAIN("Call to GetAdaptersAddresses failed with error " + itos(err)); ERR_FAIL(); return; }; IP_ADAPTER_ADDRESSES* adapter = addrs; while (adapter != NULL) { IP_ADAPTER_UNICAST_ADDRESS* address = adapter->FirstUnicastAddress; while (address != NULL) { char addr_chr[INET_ADDRSTRLEN]; SOCKADDR_IN* ipv4 = reinterpret_cast<SOCKADDR_IN*>(address->Address.lpSockaddr); IP_Address ip; ip.host= *((unsigned long*)&ipv4->sin_addr); //inet_ntop(AF_INET, &ipv4->sin_addr, addr_chr, INET_ADDRSTRLEN); r_addresses->push_back(ip); address = address->Next; }; adapter = adapter->Next; }; memfree(addrs); };
void EMWSPeer::read_msg(uint8_t *p_data, uint32_t p_size, bool p_is_string) { if (in_buffer.space_left() < p_size + 5) { ERR_EXPLAIN("Buffer full! Dropping data"); ERR_FAIL(); } uint8_t is_string = p_is_string ? 1 : 0; in_buffer.write((uint8_t *)&p_size, 4); in_buffer.write((uint8_t *)&is_string, 1); in_buffer.write(p_data, p_size); queue_count++; }
void CanvasItem::draw_colored_polygon(const Vector<Point2>& p_points, const Color& p_color,const Vector<Point2>& p_uvs, Ref<Texture> p_texture) { if (!drawing) { ERR_EXPLAIN("Drawing is only allowed inside NOTIFICATION_DRAW, _draw() function or 'draw' signal."); ERR_FAIL(); } Vector<Color> colors; colors.push_back(p_color); RID rid = p_texture.is_valid() ? p_texture->get_rid() : RID(); VisualServer::get_singleton()->canvas_item_add_polygon(canvas_item,p_points,colors,p_uvs,rid); }