mirror of
https://github.com/Relintai/pandemonium_engine.git
synced 2024-12-22 11:56:49 +01:00
365 lines
10 KiB
C++
365 lines
10 KiB
C++
#include "paint_node.h"
|
|
|
|
#include "../paint_utilities.h"
|
|
#include "core/math/geometry.h"
|
|
#include "paint_project.h"
|
|
|
|
Vector2i PaintNode::get_size() {
|
|
return _size;
|
|
}
|
|
void PaintNode::set_size(const Vector2i &size) {
|
|
if (size == _size) {
|
|
return;
|
|
}
|
|
|
|
_size = size;
|
|
|
|
emit_signal("size_changed");
|
|
_propagate_notification_resized();
|
|
update();
|
|
}
|
|
|
|
bool PaintNode::get_draw_outline() {
|
|
return _draw_outline;
|
|
}
|
|
void PaintNode::set_draw_outline(const bool val) {
|
|
_draw_outline = val;
|
|
|
|
update();
|
|
}
|
|
|
|
Ref<Image> PaintNode::render_image() {
|
|
_propagate_notification_project_pre_render();
|
|
Ref<Image> img = call("_render_image");
|
|
_propagate_notification_project_post_render();
|
|
|
|
return img;
|
|
}
|
|
Ref<Image> PaintNode::_render_image() {
|
|
Ref<Image> image;
|
|
image.instance();
|
|
|
|
Vector2i size = get_size();
|
|
|
|
if (size.x <= 0 || size.y <= 0) {
|
|
return image;
|
|
}
|
|
|
|
image->create(size.x, size.y, false, Image::FORMAT_RGBA8);
|
|
|
|
for (int i = 0; i < get_child_count(); ++i) {
|
|
PaintNode *pn = Object::cast_to<PaintNode>(get_child(i));
|
|
|
|
if (pn && pn->is_visible()) {
|
|
//dont apply own transform
|
|
render_evaluate_paint_node(pn, Transform2D(), image);
|
|
}
|
|
}
|
|
|
|
render_paint_node(this, Transform2D(), image);
|
|
|
|
return image;
|
|
}
|
|
|
|
Ref<Image> PaintNode::get_rendered_image() {
|
|
return call("_get_rendered_image");
|
|
}
|
|
Ref<Image> PaintNode::_get_rendered_image() {
|
|
return Ref<Image>();
|
|
}
|
|
|
|
bool PaintNode::render_should_evaluate_children() {
|
|
return call("_render_should_evaluate_children");
|
|
}
|
|
bool PaintNode::_render_should_evaluate_children() {
|
|
return true;
|
|
}
|
|
|
|
void PaintNode::render_evaluate_paint_node(PaintNode *node, Transform2D transform, Ref<Image> image) {
|
|
ERR_FAIL_COND(!node);
|
|
ERR_FAIL_COND(!image.is_valid());
|
|
|
|
Transform2D currtf = transform * node->get_transform();
|
|
|
|
if (node->render_should_evaluate_children()) {
|
|
for (int i = 0; i < node->get_child_count(); ++i) {
|
|
PaintNode *pn = Object::cast_to<PaintNode>(node->get_child(i));
|
|
|
|
if (pn && pn->is_visible()) {
|
|
render_evaluate_paint_node(pn, currtf, image);
|
|
}
|
|
}
|
|
}
|
|
|
|
render_paint_node(node, currtf, image);
|
|
}
|
|
|
|
void PaintNode::render_paint_node(PaintNode *node, Transform2D transform, Ref<Image> image) {
|
|
ERR_FAIL_COND(!node);
|
|
ERR_FAIL_COND(!image.is_valid());
|
|
|
|
Ref<Image> save_image = node->get_rendered_image();
|
|
|
|
if (!save_image.is_valid() || save_image->empty()) {
|
|
return;
|
|
}
|
|
|
|
Vector2i save_image_size = save_image->get_size();
|
|
Vector2i image_size = image->get_size();
|
|
|
|
// NOTE: this is EXTREMELY inefficient, and slow, however it does work for now.
|
|
// It will be rewritten soon.
|
|
|
|
Vector2 p0 = transform.xform(Vector2(0, 0));
|
|
Vector2 p1 = transform.xform(Vector2(0, save_image_size.y));
|
|
Vector2 p2 = transform.xform(Vector2(save_image_size.x, 0));
|
|
Vector2 p3 = transform.xform(Vector2(save_image_size.x, save_image_size.y));
|
|
|
|
Vector<Point2i> queued_points = Geometry::brenzenham_line(p0.x, p1.x, p0.y, p1.y);
|
|
queued_points.append_array(Geometry::brenzenham_line(p1.x, p3.x, p1.y, p3.y));
|
|
queued_points.append_array(Geometry::brenzenham_line(p2.x, p3.x, p2.y, p3.y));
|
|
queued_points.append_array(Geometry::brenzenham_line(p0.x, p2.x, p0.y, p2.y));
|
|
|
|
Vector<Point2i> points_to_check;
|
|
|
|
for (int i = 0; i < queued_points.size(); ++i) {
|
|
Point2i p = queued_points[i];
|
|
|
|
Vector<Point2i> points = Geometry::brenzenham_line(p0.x, p.x, p0.y, p.y);
|
|
points.append_array(Geometry::brenzenham_line(p3.x, p.x, p3.y, p.y));
|
|
points.append_array(Geometry::brenzenham_line(p2.x, p.x, p2.y, p.y));
|
|
points.append_array(Geometry::brenzenham_line(p1.x, p.x, p1.y, p.y));
|
|
|
|
for (int j = 0; j < points.size(); ++j) {
|
|
Point2i pc = points[j];
|
|
|
|
if (points_to_check.find(pc) == -1) {
|
|
points_to_check.push_back(pc);
|
|
}
|
|
}
|
|
}
|
|
|
|
Transform2D inverse = transform.affine_inverse();
|
|
|
|
save_image->lock();
|
|
image->lock();
|
|
|
|
for (int i = 0; i < points_to_check.size(); ++i) {
|
|
Point2i p = points_to_check[i];
|
|
|
|
if (p.x < 0 || p.y < 0 || p.x >= image_size.x || p.y >= image_size.y) {
|
|
continue;
|
|
}
|
|
|
|
Vector2 npos = inverse.xform(Vector2(p.x, p.y));
|
|
|
|
if (npos.x < 0 || npos.y < 0 || npos.x >= save_image_size.x || npos.y >= save_image_size.y) {
|
|
continue;
|
|
}
|
|
|
|
Color sic = save_image->get_pixel(npos.x, npos.y);
|
|
Color oic = image->get_pixel(p.x, p.y);
|
|
|
|
image->set_pixel(p.x, p.y, oic.blend(sic));
|
|
}
|
|
|
|
image->unlock();
|
|
save_image->unlock();
|
|
}
|
|
|
|
PoolVector2iArray PaintNode::util_get_pixels_in_line(const Vector2i &from, const Vector2i &to) {
|
|
return PaintUtilities::get_pixels_in_line(from, to);
|
|
}
|
|
|
|
int PaintNode::util_to_1d_v(const Vector2i &p, int w) {
|
|
return PaintUtilities::to_1D_v(p, w);
|
|
}
|
|
int PaintNode::util_to_1d(int x, int y, int w) {
|
|
return PaintUtilities::to_1D(x, y, w);
|
|
}
|
|
Vector2i PaintNode::util_to_2d(int idx, int w) {
|
|
return PaintUtilities::to_2D(idx, w);
|
|
}
|
|
|
|
Color PaintNode::util_color_from_array(const PoolRealArray &color_array) {
|
|
return PaintUtilities::color_from_array(color_array);
|
|
}
|
|
Color PaintNode::util_random_color() {
|
|
return PaintUtilities::random_color();
|
|
}
|
|
Color PaintNode::util_random_color_alt() {
|
|
return PaintUtilities::random_color_alt();
|
|
}
|
|
|
|
bool PaintNode::forward_canvas_gui_input(const Ref<InputEvent> &p_event) {
|
|
return call("_forward_canvas_gui_input", p_event);
|
|
}
|
|
bool PaintNode::_forward_canvas_gui_input(const Ref<InputEvent> &p_event) {
|
|
return false;
|
|
}
|
|
|
|
PaintProject *PaintNode::get_paint_project() {
|
|
PaintNode *p = this;
|
|
|
|
while (p) {
|
|
PaintProject *pp = Object::cast_to<PaintProject>(p);
|
|
|
|
if (pp) {
|
|
return pp;
|
|
}
|
|
|
|
p = Object::cast_to<PaintNode>(p->get_parent());
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
PaintNode *PaintNode::get_parent_paint_node() {
|
|
return Object::cast_to<PaintNode>(get_parent());
|
|
}
|
|
|
|
PaintNode *PaintNode::find_parent_paint_node() {
|
|
Node *p = get_parent();
|
|
|
|
while (p) {
|
|
PaintNode *pn = Object::cast_to<PaintNode>(p);
|
|
|
|
if (pn) {
|
|
return pn;
|
|
}
|
|
|
|
p = Object::cast_to<PaintNode>(p->get_parent());
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
String PaintNode::get_configuration_warning() const {
|
|
const PaintNode *p = this;
|
|
|
|
while (p) {
|
|
const PaintProject *pp = Object::cast_to<PaintProject>(p);
|
|
|
|
if (pp) {
|
|
return "";
|
|
}
|
|
|
|
p = Object::cast_to<PaintNode>(p->get_parent());
|
|
}
|
|
|
|
return "This Node should be a child of a PaintProject!";
|
|
}
|
|
|
|
void PaintNode::_propagate_notification_resized() {
|
|
//Only send it to children
|
|
//So if they don't resize themselves, the notification stops
|
|
|
|
for (int i = 0; i < get_child_count(); ++i) {
|
|
PaintNode *pn = Object::cast_to<PaintNode>(get_child(i));
|
|
|
|
if (pn) {
|
|
pn->notification(NOTIFICATION_PARENT_PAINT_NODE_RESIZED);
|
|
}
|
|
}
|
|
}
|
|
|
|
void PaintNode::_propagate_notification_project_pre_render() {
|
|
notification(NOTIFICATION_PAINT_PROJECT_PRE_RENDER);
|
|
|
|
for (int i = 0; i < get_child_count(); ++i) {
|
|
PaintNode *pn = Object::cast_to<PaintNode>(get_child(i));
|
|
|
|
if (pn) {
|
|
pn->_propagate_notification_project_pre_render();
|
|
}
|
|
}
|
|
}
|
|
void PaintNode::_propagate_notification_project_post_render() {
|
|
notification(NOTIFICATION_PAINT_PROJECT_POST_RENDER);
|
|
|
|
for (int i = 0; i < get_child_count(); ++i) {
|
|
PaintNode *pn = Object::cast_to<PaintNode>(get_child(i));
|
|
|
|
if (pn) {
|
|
pn->_propagate_notification_project_post_render();
|
|
}
|
|
}
|
|
}
|
|
|
|
PaintNode::PaintNode() {
|
|
_draw_outline = true;
|
|
}
|
|
|
|
PaintNode::~PaintNode() {
|
|
}
|
|
|
|
void PaintNode::_notification(int p_what) {
|
|
switch (p_what) {
|
|
case NOTIFICATION_POST_ENTER_TREE: {
|
|
if (get_size() == Vector2i(0, 0)) {
|
|
PaintNode *pn = get_parent_paint_node();
|
|
|
|
if (pn) {
|
|
set_size(pn->get_size());
|
|
}
|
|
}
|
|
} break;
|
|
case NOTIFICATION_DRAW: {
|
|
if (_draw_outline) {
|
|
draw_line(Point2(0, 0), Point2(_size.x, 0), Color(0, 0, 0, 1));
|
|
draw_line(Point2(0, _size.y), Point2(_size.x, _size.y), Color(0, 0, 0, 1));
|
|
draw_line(Point2(0, 0), Point2(0, _size.y), Color(0, 0, 0, 1));
|
|
draw_line(Point2(_size.x, 0), Point2(_size.x, _size.y), Color(0, 0, 0, 1));
|
|
}
|
|
} break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void PaintNode::_bind_methods() {
|
|
ADD_SIGNAL(MethodInfo("size_changed"));
|
|
|
|
ClassDB::bind_method(D_METHOD("get_size"), &PaintNode::get_size);
|
|
ClassDB::bind_method(D_METHOD("set_size", "size"), &PaintNode::set_size);
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2I, "size"), "set_size", "get_size");
|
|
|
|
ClassDB::bind_method(D_METHOD("get_draw_outline"), &PaintNode::get_draw_outline);
|
|
ClassDB::bind_method(D_METHOD("set_draw_outline", "val"), &PaintNode::set_draw_outline);
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "draw_outline"), "set_draw_outline", "get_draw_outline");
|
|
|
|
BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::OBJECT, "r", PROPERTY_HINT_RESOURCE_TYPE, "Image"), "_render_image"));
|
|
ClassDB::bind_method(D_METHOD("render_image"), &PaintNode::render_image);
|
|
ClassDB::bind_method(D_METHOD("_render_image"), &PaintNode::_render_image);
|
|
|
|
BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::OBJECT, "r", PROPERTY_HINT_RESOURCE_TYPE, "Image"), "_get_rendered_image"));
|
|
ClassDB::bind_method(D_METHOD("get_rendered_image"), &PaintNode::get_rendered_image);
|
|
ClassDB::bind_method(D_METHOD("_get_rendered_image"), &PaintNode::_get_rendered_image);
|
|
|
|
BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::BOOL, "r"), "_render_should_evaluate_children"));
|
|
ClassDB::bind_method(D_METHOD("render_should_evaluate_children"), &PaintNode::render_should_evaluate_children);
|
|
ClassDB::bind_method(D_METHOD("_render_should_evaluate_children"), &PaintNode::_render_should_evaluate_children);
|
|
|
|
ClassDB::bind_method(D_METHOD("util_get_pixels_in_line", "from", "to"), &PaintNode::util_get_pixels_in_line);
|
|
|
|
ClassDB::bind_method(D_METHOD("util_to_1d_v", "p", "w"), &PaintNode::util_to_1d_v);
|
|
ClassDB::bind_method(D_METHOD("util_to_1d", "x", "y", "w"), &PaintNode::util_to_1d);
|
|
ClassDB::bind_method(D_METHOD("util_to_2d", "idx", "w"), &PaintNode::util_to_2d);
|
|
|
|
ClassDB::bind_method(D_METHOD("util_color_from_array", "color_array"), &PaintNode::util_color_from_array);
|
|
ClassDB::bind_method(D_METHOD("util_random_color"), &PaintNode::util_random_color);
|
|
ClassDB::bind_method(D_METHOD("util_random_color_alt"), &PaintNode::util_random_color_alt);
|
|
|
|
BIND_VMETHOD(MethodInfo(Variant::BOOL, "_forward_canvas_gui_input", PropertyInfo(Variant::OBJECT, "event", PROPERTY_HINT_RESOURCE_TYPE, "InputEvent")));
|
|
ClassDB::bind_method(D_METHOD("forward_canvas_gui_input", "event"), &PaintNode::forward_canvas_gui_input);
|
|
ClassDB::bind_method(D_METHOD("_forward_canvas_gui_input", "event"), &PaintNode::_forward_canvas_gui_input);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_paint_project"), &PaintNode::get_paint_project);
|
|
ClassDB::bind_method(D_METHOD("get_parent_paint_node"), &PaintNode::get_parent_paint_node);
|
|
ClassDB::bind_method(D_METHOD("find_parent_paint_node"), &PaintNode::find_parent_paint_node);
|
|
|
|
BIND_CONSTANT(NOTIFICATION_PARENT_PAINT_NODE_RESIZED);
|
|
BIND_CONSTANT(NOTIFICATION_PAINT_PROJECT_PRE_RENDER);
|
|
BIND_CONSTANT(NOTIFICATION_PAINT_PROJECT_POST_RENDER);
|
|
}
|