mirror of
https://github.com/Relintai/pandemonium_engine.git
synced 2024-12-23 20:36:53 +01:00
322 lines
12 KiB
C++
322 lines
12 KiB
C++
/*************************************************************************/
|
|
/* mm_node.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* PANDEMONIUM ENGINE */
|
|
/* https://github.com/Relintai/pandemonium_engine */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2022-present Péter Magyar. */
|
|
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
|
|
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
|
|
#include "mm_node.h"
|
|
|
|
#include "../editor/mm_graph_node.h"
|
|
#include "core/object/object.h"
|
|
#include "mm_material.h"
|
|
#include "mm_node_universal_property.h"
|
|
#include "scene/main/node.h"
|
|
|
|
Vector2 MMNode::get_graph_position() {
|
|
return graph_position;
|
|
}
|
|
|
|
void MMNode::set_graph_position(const Vector2 &pos) {
|
|
graph_position = pos;
|
|
emit_changed();
|
|
}
|
|
|
|
Vector<Variant> MMNode::get_input_properties() {
|
|
Vector<Variant> r;
|
|
for (int i = 0; i < input_properties.size(); i++) {
|
|
r.push_back(input_properties[i].get_ref_ptr());
|
|
}
|
|
return r;
|
|
}
|
|
|
|
void MMNode::set_input_properties(const Vector<Variant> &val) {
|
|
input_properties.clear();
|
|
for (int i = 0; i < val.size(); i++) {
|
|
Ref<MMNodeUniversalProperty> e = Ref<MMNodeUniversalProperty>(val[i]);
|
|
input_properties.push_back(e);
|
|
}
|
|
}
|
|
|
|
Vector<Variant> MMNode::get_output_properties() {
|
|
Vector<Variant> r;
|
|
for (int i = 0; i < output_properties.size(); i++) {
|
|
r.push_back(output_properties[i].get_ref_ptr());
|
|
}
|
|
return r;
|
|
}
|
|
|
|
void MMNode::set_output_properties(const Vector<Variant> &val) {
|
|
output_properties.clear();
|
|
for (int i = 0; i < val.size(); i++) {
|
|
Ref<MMNodeUniversalProperty> e = Ref<MMNodeUniversalProperty>(val[i]);
|
|
output_properties.push_back(e);
|
|
}
|
|
}
|
|
|
|
bool MMNode::get_properties_initialized() const {
|
|
return properties_initialized;
|
|
}
|
|
|
|
void MMNode::set_properties_initialized(const bool val) {
|
|
properties_initialized = val;
|
|
}
|
|
|
|
bool MMNode::get_dirty() const {
|
|
return dirty;
|
|
}
|
|
|
|
void MMNode::set_dirty(const bool val) {
|
|
bool changed = val != dirty;
|
|
dirty = val;
|
|
|
|
if (changed) {
|
|
emit_changed();
|
|
}
|
|
}
|
|
|
|
bool MMNode::render(const Ref<MMMaterial> &material) {
|
|
if (!dirty) {
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < input_properties.size(); ++i) {
|
|
Ref<MMNodeUniversalProperty> p = input_properties[i];
|
|
|
|
if (!p.is_valid()) {
|
|
continue;
|
|
}
|
|
|
|
if (p->get_input_property().is_valid() && p->get_input_property()->get_owner()->get_dirty()) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
call("_render", material);
|
|
|
|
dirty = false;
|
|
return true;
|
|
}
|
|
|
|
void MMNode::_render(const Ref<MMMaterial> &material) {
|
|
}
|
|
|
|
Ref<Image> MMNode::render_image(const Ref<MMMaterial> &material) {
|
|
return call("_render_image", material);
|
|
}
|
|
|
|
Ref<Image> MMNode::_render_image(const Ref<MMMaterial> &material) {
|
|
Ref<Image> image;
|
|
image.instance();
|
|
|
|
image->create(material->image_size.x, material->image_size.y, false, Image::FORMAT_RGBA8);
|
|
image->lock();
|
|
|
|
float w = image->get_width();
|
|
float h = image->get_height();
|
|
float pseed = Math::randf() + Math::rand();
|
|
|
|
for (int x = 0; x < image->get_width(); ++x) { //x in range(image.get_width())
|
|
|
|
for (int y = 0; y < image->get_height(); ++y) { //y in range(image.get_height())
|
|
Vector2 v = Vector2(x / w, y / h);
|
|
Color col = get_value_for(v, pseed);
|
|
image->set_pixel(x, y, col);
|
|
}
|
|
}
|
|
|
|
image->unlock();
|
|
return image;
|
|
}
|
|
|
|
Color MMNode::get_value_for(const Vector2 &uv, const int pseed) {
|
|
return call("_get_value_for", uv, pseed);
|
|
}
|
|
|
|
Color MMNode::_get_value_for(const Vector2 &uv, const int pseed) {
|
|
return Color();
|
|
}
|
|
|
|
void MMNode::init_properties() {
|
|
if (!properties_initialized) {
|
|
properties_initialized = true;
|
|
call("_init_properties");
|
|
}
|
|
}
|
|
|
|
void MMNode::_init_properties() {
|
|
}
|
|
|
|
void MMNode::register_methods(Node *mm_graph_node) {
|
|
init_properties();
|
|
call("_register_methods", mm_graph_node);
|
|
}
|
|
|
|
void MMNode::_register_methods_bind(Node *mm_graph_node) {
|
|
MMGraphNode *gn = Object::cast_to<MMGraphNode>(mm_graph_node);
|
|
|
|
ERR_FAIL_COND(!gn);
|
|
|
|
_register_methods(gn);
|
|
}
|
|
|
|
void MMNode::_register_methods(MMGraphNode *mm_graph_node) {
|
|
}
|
|
|
|
void MMNode::register_input_property(const Ref<MMNodeUniversalProperty> &p_prop) {
|
|
Ref<MMNodeUniversalProperty> prop = p_prop;
|
|
|
|
prop->set_owner(this);
|
|
|
|
if (!prop->is_connected("changed", this, "on_input_property_changed")) {
|
|
prop->connect("changed", this, "on_input_property_changed");
|
|
}
|
|
|
|
input_properties.erase(prop);
|
|
input_properties.push_back(prop);
|
|
}
|
|
|
|
void MMNode::unregister_input_property(const Ref<MMNodeUniversalProperty> &p_prop) {
|
|
Ref<MMNodeUniversalProperty> prop = p_prop;
|
|
|
|
if (prop->get_owner() == this) {
|
|
prop->set_owner(nullptr);
|
|
}
|
|
|
|
if (prop->is_connected("changed", this, "on_input_property_changed")) {
|
|
prop->disconnect("changed", this, "on_input_property_changed");
|
|
}
|
|
|
|
input_properties.erase(prop);
|
|
}
|
|
|
|
void MMNode::register_output_property(const Ref<MMNodeUniversalProperty> &p_prop) {
|
|
Ref<MMNodeUniversalProperty> prop = p_prop;
|
|
|
|
prop->set_owner(this);
|
|
|
|
output_properties.erase(prop);
|
|
output_properties.push_back(prop);
|
|
}
|
|
|
|
void MMNode::unregister_output_property(const Ref<MMNodeUniversalProperty> &p_prop) {
|
|
Ref<MMNodeUniversalProperty> prop = p_prop;
|
|
|
|
if (prop->get_owner() == this) {
|
|
prop->set_owner(nullptr);
|
|
}
|
|
|
|
output_properties.erase(prop);
|
|
}
|
|
|
|
void MMNode::on_input_property_changed() {
|
|
set_dirty(true);
|
|
emit_changed();
|
|
}
|
|
|
|
Variant MMNode::get_property_value(const Vector2 &uv) {
|
|
return call("_get_property_value", uv);
|
|
}
|
|
|
|
Variant MMNode::_get_property_value(const Vector2 &uv) {
|
|
return Variant();
|
|
}
|
|
|
|
Vector2 MMNode::get_property_value_sdf3d(const Vector3 &uv3) {
|
|
return call("_get_property_value_sdf3d", uv3);
|
|
}
|
|
|
|
Vector2 MMNode::_get_property_value_sdf3d(const Vector3 &uv3) {
|
|
return Vector2();
|
|
}
|
|
|
|
MMNode::MMNode() {
|
|
properties_initialized = false;
|
|
dirty = true;
|
|
}
|
|
|
|
MMNode::~MMNode() {
|
|
}
|
|
|
|
void MMNode::_bind_methods() {
|
|
ClassDB::bind_method(D_METHOD("get_graph_position"), &MMNode::get_graph_position);
|
|
ClassDB::bind_method(D_METHOD("set_graph_position", "value"), &MMNode::set_graph_position);
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "graph_position"), "set_graph_position", "get_graph_position");
|
|
|
|
ClassDB::bind_method(D_METHOD("get_input_properties"), &MMNode::get_input_properties);
|
|
ClassDB::bind_method(D_METHOD("set_input_properties", "value"), &MMNode::set_input_properties);
|
|
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "input_properties", PROPERTY_HINT_NONE, "23/20:MMNodeUniversalProperty", PROPERTY_USAGE_EDITOR, "MMNodeUniversalProperty"), "set_input_properties", "get_input_properties");
|
|
|
|
ClassDB::bind_method(D_METHOD("get_output_properties"), &MMNode::get_output_properties);
|
|
ClassDB::bind_method(D_METHOD("set_output_properties", "value"), &MMNode::set_output_properties);
|
|
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "output_properties", PROPERTY_HINT_NONE, "23/20:MMNodeUniversalProperty", PROPERTY_USAGE_EDITOR, "MMNodeUniversalProperty"), "set_output_properties", "get_output_properties");
|
|
|
|
ClassDB::bind_method(D_METHOD("get_properties_initialized"), &MMNode::get_properties_initialized);
|
|
ClassDB::bind_method(D_METHOD("set_properties_initialized", "value"), &MMNode::set_properties_initialized);
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "properties_initialized", PROPERTY_HINT_NONE, "", 0), "set_properties_initialized", "get_properties_initialized");
|
|
|
|
ClassDB::bind_method(D_METHOD("get_dirty"), &MMNode::get_dirty);
|
|
ClassDB::bind_method(D_METHOD("set_dirty", "value"), &MMNode::set_dirty);
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "dirty", PROPERTY_HINT_NONE, "", 0), "set_dirty", "get_dirty");
|
|
|
|
BIND_VMETHOD(MethodInfo("_render", PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "MMMaterial")));
|
|
ClassDB::bind_method(D_METHOD("render", "material"), &MMNode::render);
|
|
ClassDB::bind_method(D_METHOD("_render", "material"), &MMNode::_render);
|
|
|
|
BIND_VMETHOD(MethodInfo("_render_image", PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "MMMaterial")));
|
|
ClassDB::bind_method(D_METHOD("render_image", "material"), &MMNode::render_image);
|
|
ClassDB::bind_method(D_METHOD("_render_image", "material"), &MMNode::_render_image);
|
|
|
|
BIND_VMETHOD(MethodInfo("_get_value_for", PropertyInfo(Variant::VECTOR2, "uv"), PropertyInfo(Variant::INT, "pseed")));
|
|
ClassDB::bind_method(D_METHOD("get_value_for", "uv", "pseed"), &MMNode::get_value_for);
|
|
ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &MMNode::_get_value_for);
|
|
|
|
BIND_VMETHOD(MethodInfo("_init_properties"));
|
|
ClassDB::bind_method(D_METHOD("init_properties"), &MMNode::init_properties);
|
|
ClassDB::bind_method(D_METHOD("_init_properties"), &MMNode::_init_properties);
|
|
|
|
BIND_VMETHOD(MethodInfo("_register_methods", PropertyInfo(Variant::OBJECT, "mm_graph_node")));
|
|
ClassDB::bind_method(D_METHOD("register_methods", "mm_graph_node"), &MMNode::register_methods);
|
|
ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &MMNode::_register_methods_bind);
|
|
|
|
ClassDB::bind_method(D_METHOD("register_input_property", "prop"), &MMNode::register_input_property);
|
|
ClassDB::bind_method(D_METHOD("unregister_input_property", "prop"), &MMNode::unregister_input_property);
|
|
|
|
ClassDB::bind_method(D_METHOD("register_output_property", "prop"), &MMNode::register_output_property);
|
|
ClassDB::bind_method(D_METHOD("unregister_output_property", "prop"), &MMNode::unregister_output_property);
|
|
|
|
ClassDB::bind_method(D_METHOD("on_input_property_changed"), &MMNode::on_input_property_changed);
|
|
|
|
BIND_VMETHOD(MethodInfo("_get_property_value", PropertyInfo(Variant::VECTOR2, "uv")));
|
|
ClassDB::bind_method(D_METHOD("get_property_value", "uv"), &MMNode::get_property_value);
|
|
ClassDB::bind_method(D_METHOD("_get_property_value", "uv"), &MMNode::_get_property_value);
|
|
|
|
BIND_VMETHOD(MethodInfo("_get_property_value_sdf3d", PropertyInfo(Variant::VECTOR3, "uv3")));
|
|
ClassDB::bind_method(D_METHOD("get_property_value_sdf3d", "uv3"), &MMNode::get_property_value_sdf3d);
|
|
ClassDB::bind_method(D_METHOD("_get_property_value_sdf3d", "uv3"), &MMNode::_get_property_value_sdf3d);
|
|
}
|