void SpriteEditor::_create_light_occluder_2d_node() { for (int i = 0; i < computed_outline_lines.size(); i++) { Vector<Vector2> outline = computed_outline_lines[i]; if (outline.size() < 3) { err_dialog->set_text(TTR("Invalid geometry, can't create light occluder.")); err_dialog->popup_centered_minsize(); continue; } Ref<OccluderPolygon2D> polygon; polygon.instance(); PoolVector2Array a; a.resize(outline.size()); PoolVector2Array::Write aw = a.write(); for (int io = 0; io < outline.size(); io++) { aw[io] = outline[io]; } polygon->set_polygon(a); LightOccluder2D *light_occluder_2d_instance = memnew(LightOccluder2D); light_occluder_2d_instance->set_occluder_polygon(polygon); _add_as_sibling_or_child(node, light_occluder_2d_instance); } }
PoolVector2Array mono_array_to_PoolVector2Array(MonoArray *p_array) { PoolVector2Array ret; int length = mono_array_length(p_array); for (int i = 0; i < length; i++) { real_t *raw_elem = (real_t *)mono_array_addr_with_size(p_array, sizeof(real_t) * 2, i); MARSHALLED_IN(Vector2, raw_elem, elem); ret.push_back(elem); } return ret; }
void Curve2D::_set_data(const Dictionary &p_data) { ERR_FAIL_COND(!p_data.has("points")); PoolVector2Array rp = p_data["points"]; int pc = rp.size(); ERR_FAIL_COND(pc % 3 != 0); points.resize(pc / 3); PoolVector2Array::Read r = rp.read(); for (int i = 0; i < points.size(); i++) { points[i].in = r[i * 3 + 0]; points[i].out = r[i * 3 + 1]; points[i].pos = r[i * 3 + 2]; } baked_cache_dirty = true; }
Dictionary Curve2D::_get_data() const { Dictionary dc; PoolVector2Array d; d.resize(points.size() * 3); PoolVector2Array::Write w = d.write(); for (int i = 0; i < points.size(); i++) { w[i * 3 + 0] = points[i].in; w[i * 3 + 1] = points[i].out; w[i * 3 + 2] = points[i].pos; } w = PoolVector2Array::Write(); dc["points"] = d; return dc; }
PoolVector2Array Curve2D::tesselate(int p_max_stages, float p_tolerance) const { PoolVector2Array tess; if (points.size() == 0) { return tess; } Vector<Map<float, Vector2> > midpoints; midpoints.resize(points.size() - 1); int pc = 1; for (int i = 0; i < points.size() - 1; i++) { _bake_segment2d(midpoints[i], 0, 1, points[i].pos, points[i].out, points[i + 1].pos, points[i + 1].in, 0, p_max_stages, p_tolerance); pc++; pc += midpoints[i].size(); } tess.resize(pc); PoolVector2Array::Write bpw = tess.write(); bpw[0] = points[0].pos; int pidx = 0; for (int i = 0; i < points.size() - 1; i++) { for (Map<float, Vector2>::Element *E = midpoints[i].front(); E; E = E->next()) { pidx++; bpw[pidx] = E->get(); } pidx++; bpw[pidx] = points[i + 1].pos; } bpw = PoolVector2Array::Write(); return tess; }
void SpriteEditor::_convert_to_polygon_2d_node() { Polygon2D *polygon_2d_instance = memnew(Polygon2D); int total_point_count = 0; for (int i = 0; i < computed_outline_lines.size(); i++) total_point_count += computed_outline_lines[i].size(); PoolVector2Array polygon; polygon.resize(total_point_count); PoolVector2Array::Write polygon_write = polygon.write(); PoolVector2Array uvs; uvs.resize(total_point_count); PoolVector2Array::Write uvs_write = uvs.write(); int current_point_index = 0; Array polys; polys.resize(computed_outline_lines.size()); for (int i = 0; i < computed_outline_lines.size(); i++) { Vector<Vector2> outline = computed_outline_lines[i]; Vector<Vector2> uv_outline = outline_lines[i]; if (outline.size() < 3) { err_dialog->set_text(TTR("Invalid geometry, can't create polygon.")); err_dialog->popup_centered_minsize(); return; } PoolIntArray pia; pia.resize(outline.size()); PoolIntArray::Write pia_write = pia.write(); for (int pi = 0; pi < outline.size(); pi++) { polygon_write[current_point_index] = outline[pi]; uvs_write[current_point_index] = uv_outline[pi]; pia_write[pi] = current_point_index; current_point_index++; } polys[i] = pia; } polygon_2d_instance->set_uv(uvs); polygon_2d_instance->set_polygon(polygon); polygon_2d_instance->set_polygons(polys); EditorNode::get_singleton()->get_scene_tree_dock()->replace_node(node, polygon_2d_instance); }
void CPUParticles2DEditorPlugin::_generate_emission_mask() { Ref<Image> img; img.instance(); Error err = ImageLoader::load_image(source_emission_file, img); ERR_EXPLAIN(TTR("Error loading image:") + " " + source_emission_file); ERR_FAIL_COND(err != OK); if (img->is_compressed()) { img->decompress(); } img->convert(Image::FORMAT_RGBA8); ERR_FAIL_COND(img->get_format() != Image::FORMAT_RGBA8); Size2i s = Size2(img->get_width(), img->get_height()); ERR_FAIL_COND(s.width == 0 || s.height == 0); Vector<Point2> valid_positions; Vector<Point2> valid_normals; Vector<uint8_t> valid_colors; valid_positions.resize(s.width * s.height); EmissionMode emode = (EmissionMode)emission_mask_mode->get_selected(); if (emode == EMISSION_MODE_BORDER_DIRECTED) { valid_normals.resize(s.width * s.height); } bool capture_colors = emission_colors->is_pressed(); if (capture_colors) { valid_colors.resize(s.width * s.height * 4); } int vpc = 0; { PoolVector<uint8_t> data = img->get_data(); PoolVector<uint8_t>::Read r = data.read(); for (int i = 0; i < s.width; i++) { for (int j = 0; j < s.height; j++) { uint8_t a = r[(j * s.width + i) * 4 + 3]; if (a > 128) { if (emode == EMISSION_MODE_SOLID) { if (capture_colors) { valid_colors.write[vpc * 4 + 0] = r[(j * s.width + i) * 4 + 0]; valid_colors.write[vpc * 4 + 1] = r[(j * s.width + i) * 4 + 1]; valid_colors.write[vpc * 4 + 2] = r[(j * s.width + i) * 4 + 2]; valid_colors.write[vpc * 4 + 3] = r[(j * s.width + i) * 4 + 3]; } valid_positions.write[vpc++] = Point2(i, j); } else { bool on_border = false; for (int x = i - 1; x <= i + 1; x++) { for (int y = j - 1; y <= j + 1; y++) { if (x < 0 || y < 0 || x >= s.width || y >= s.height || r[(y * s.width + x) * 4 + 3] <= 128) { on_border = true; break; } } if (on_border) break; } if (on_border) { valid_positions.write[vpc] = Point2(i, j); if (emode == EMISSION_MODE_BORDER_DIRECTED) { Vector2 normal; for (int x = i - 2; x <= i + 2; x++) { for (int y = j - 2; y <= j + 2; y++) { if (x == i && y == j) continue; if (x < 0 || y < 0 || x >= s.width || y >= s.height || r[(y * s.width + x) * 4 + 3] <= 128) { normal += Vector2(x - i, y - j).normalized(); } } } normal.normalize(); valid_normals.write[vpc] = normal; } if (capture_colors) { valid_colors.write[vpc * 4 + 0] = r[(j * s.width + i) * 4 + 0]; valid_colors.write[vpc * 4 + 1] = r[(j * s.width + i) * 4 + 1]; valid_colors.write[vpc * 4 + 2] = r[(j * s.width + i) * 4 + 2]; valid_colors.write[vpc * 4 + 3] = r[(j * s.width + i) * 4 + 3]; } vpc++; } } } } } } valid_positions.resize(vpc); if (valid_normals.size()) { valid_normals.resize(vpc); } ERR_EXPLAIN(TTR("No pixels with transparency > 128 in image...")); ERR_FAIL_COND(valid_positions.size() == 0); if (capture_colors) { PoolColorArray pca; pca.resize(vpc); PoolColorArray::Write pcaw = pca.write(); for (int i = 0; i < vpc; i += 1) { Color color; color.r = valid_colors[i * 4 + 0] / 255.0f; color.g = valid_colors[i * 4 + 1] / 255.0f; color.b = valid_colors[i * 4 + 2] / 255.0f; color.a = valid_colors[i * 4 + 3] / 255.0f; pcaw[i] = color; } particles->set_emission_colors(pca); } if (valid_normals.size()) { particles->set_emission_shape(CPUParticles2D::EMISSION_SHAPE_DIRECTED_POINTS); PoolVector2Array norms; norms.resize(valid_normals.size()); PoolVector2Array::Write normsw = norms.write(); for (int i = 0; i < valid_normals.size(); i += 1) { normsw[i] = valid_normals[i]; } particles->set_emission_normals(norms); } else { particles->set_emission_shape(CPUParticles2D::EMISSION_SHAPE_POINTS); } { PoolVector2Array points; points.resize(valid_positions.size()); PoolVector2Array::Write pointsw = points.write(); for (int i = 0; i < valid_positions.size(); i += 1) { pointsw[i] = valid_positions[i]; } particles->set_emission_points(points); } }