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);
}
}
