return physics_layers[p_layer_index].collision_mask;

}

void TileSet::set_physics_layer_physics_material(int p_layer_index, Ref<PhysicsMaterial> p_physics_material) {

ERR_FAIL_INDEX(p_layer_index, physics_layers.size());

physics_layers.write[p_layer_index].physics_material = p_physics_material;

}

set_physics_layer_collision_mask(index, p_value);

return true;

} else if (components[1] == "physics_material") {

Ref<PhysicsMaterial> physics_material = p_value;

while (index >= physics_layers.size()) {

} else if (components[1] == "collision_mask") {

r_ret = get_physics_layer_collision_mask(index);

return true;

} else if (components[1] == "physics_material") {

r_ret = get_physics_layer_physics_material(index);

return true;

}

p_list->push_back(property_info);

// physics_layer_%d/physics_material

property_info = PropertyInfo(Variant::OBJECT, vformat("physics_layer_%d/physics_material", i), PROPERTY_HINT_RESOURCE_TYPE, "PhysicsMaterial");

if (!physics_layers[i].physics_material.is_valid()) {

ClassDB::bind_method(D_METHOD("get_physics_layer_collision_layer", "layer_index"), &TileSet::get_physics_layer_collision_layer);

ClassDB::bind_method(D_METHOD("set_physics_layer_collision_mask", "layer_index", "mask"), &TileSet::set_physics_layer_collision_mask);

ClassDB::bind_method(D_METHOD("get_physics_layer_collision_mask", "layer_index"), &TileSet::get_physics_layer_collision_mask);

ClassDB::bind_method(D_METHOD("set_physics_layer_physics_material", "layer_index", "physics_material"), &TileSet::set_physics_layer_physics_material);

ClassDB::bind_method(D_METHOD("get_physics_layer_physics_material", "layer_index"), &TileSet::get_physics_layer_physics_material);

}

for (const KeyValue<int, TileData *> &E_alternative : E_tile.value.alternatives) {

// Add a dummy property to show the alternative exists.

// Get the alternative tile's properties and append them to the list of properties.

List<PropertyInfo> alternative_property_list;

E_alternative.value->get_property_list(&alternative_property_list);

for (PropertyInfo &alternative_property_info : alternative_property_list) {

if (default_value.get_type() != Variant::NIL && bool(Variant::evaluate(Variant::OP_EQUAL, value, default_value))) {

alternative_property_info.usage ^= PROPERTY_USAGE_STORAGE;

}

tile_property_list.push_back(alternative_property_info);

}

}

// Add all alternative.

for (PropertyInfo &tile_property_info : tile_property_list) {

p_list->push_back(tile_property_info);

}

}

struct PhysicsLayer {

uint32_t collision_layer = 1;

uint32_t collision_mask = 1;

Ref<PhysicsMaterial> physics_material;

};

Vector<PhysicsLayer> physics_layers;

uint32_t get_physics_layer_collision_layer(int p_layer_index) const;

void set_physics_layer_collision_mask(int p_layer_index, uint32_t p_mask);

uint32_t get_physics_layer_collision_mask(int p_layer_index) const;

void set_physics_layer_physics_material(int p_layer_index, Ref<PhysicsMaterial> p_physics_material);

Ref<PhysicsMaterial> get_physics_layer_physics_material(int p_layer_index) const;

}

String file_path = p_path;

file_path += ".wav";

}

Dictionary missing_resource_properties = p_node->get_meta(META_MISSING_RESOURCES, Dictionary());

for (const PropertyInfo &E : plist) {

continue;

}

if (do_assign) {

bool set_valid = true;

// If the property being set is a missing resource (and the parent is not),

// then setting it will most likely not work.

// Instead, save it as metadata.

if (error) {

if (error != ERR_FILE_EOF) {

_printerr();

}

}

}

if (!assign.is_empty()) {

bool set_valid = true;

// If the property being set is a missing resource (and the parent is not),

// then setting it will most likely not work.

// Instead, save it as metadata.

#endif

}

List<PropertyInfo> property_list;

res->get_property_list(&property_list);

continue;

}

String name = PE->get().name;

Variant value;

if (PE->get().usage & PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT) {

ADD_PROPERTY(PropertyInfo(Variant::INT, "max_lines_visible"), "set_max_lines_visible", "get_max_lines_visible");

ClassDB::bind_method(D_METHOD("get_line_objects", "line"), &TextParagraph::get_line_objects);

ClassDB::bind_method(D_METHOD("get_line_object_rect", "line", "key"), &TextParagraph::get_line_object_rect);

ClassDB::bind_method(D_METHOD("get_line_size", "line"), &TextParagraph::get_line_size);

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

RID line = TS->shaped_text_substr(rid, line_breaks[i], line_breaks[i + 1] - line_breaks[i]);

float h = (TS->shaped_text_get_orientation(line) == TextServer::ORIENTATION_HORIZONTAL) ? TS->shaped_text_get_size(line).y : TS->shaped_text_get_size(line).x;

if (!tab_stops.is_empty()) {

TS->shaped_text_tab_align(line, tab_stops);

}

}

size.x = MAX(size.x, lsize.x);

size.y += lsize.y;

} else {

if (h_offset > 0 && i <= dropcap_lines) {

lsize.y += h_offset;

}

size.x += lsize.x;

size.y = MAX(size.y, lsize.y);

}

}

if (h_offset > 0) {

return max_lines_visible;

}

Array TextParagraph::get_line_objects(int p_line) const {

_THREAD_SAFE_METHOD_

if (i != p_line) {

if (TS->shaped_text_get_orientation(lines_rid[i]) == TextServer::ORIENTATION_HORIZONTAL) {

ofs.x = 0.f;

} else {

ofs.y = 0.f;

}

}

}

TS->shaped_text_draw(lines_rid[i], p_canvas, ofs, clip_l, clip_l + l_width, p_color);

if (TS->shaped_text_get_orientation(lines_rid[i]) == TextServer::ORIENTATION_HORIZONTAL) {

ofs.x = p_pos.x;

} else {

ofs.y = p_pos.y;

}

}

}

TS->shaped_text_draw_outline(lines_rid[i], p_canvas, ofs, clip_l, clip_l + l_width, p_outline_size, p_color);

if (TS->shaped_text_get_orientation(lines_rid[i]) == TextServer::ORIENTATION_HORIZONTAL) {

ofs.x = p_pos.x;

} else {

ofs.y = p_pos.y;

}

}

}

if ((p_coords.y >= ofs.y) && (p_coords.y <= ofs.y + TS->shaped_text_get_size(line_rid).y)) {

return TS->shaped_text_hit_test_position(line_rid, p_coords.x);

}

} else {

if ((p_coords.x >= ofs.x) && (p_coords.x <= ofs.x + TS->shaped_text_get_size(line_rid).x)) {

return TS->shaped_text_hit_test_position(line_rid, p_coords.y);

}

}

}

return TS->shaped_text_get_range(rid).y;

}

void TextParagraph::draw_dropcap(RID p_canvas, const Vector2 &p_pos, const Color &p_color) const {

_THREAD_SAFE_METHOD_

bool lines_dirty = true;

float width = -1.0;

int max_lines_visible = -1;

void set_max_lines_visible(int p_lines);

int get_max_lines_visible() const;

Size2 get_non_wrapped_size() const;

Size2 get_size() const;

int hit_test(const Point2 &p_coords) const;

Mutex &get_mutex() const { return _thread_safe_; }

TextParagraph(const String &p_text, const Ref<Font> &p_font, int p_font_size, const String &p_language = "", float p_width = -1.f, TextServer::Direction p_direction = TextServer::DIRECTION_AUTO, TextServer::Orientation p_orientation = TextServer::ORIENTATION_HORIZONTAL);

ERR_FAIL_INDEX(p_type, TYPE_MAX);

Graph *g = &graph[p_type];

if (E->get().from_node == p_from_node && E->get().from_port == p_from_port && E->get().to_node == p_to_node && E->get().to_port == p_to_port) {

g->connections.erase(E);

g->nodes[p_from_node].next_connected_nodes.erase(p_to_node);