diff --git a/modules/material_maker/SCsub b/modules/material_maker/SCsub index ffe4c1eb5..c64e4de75 100644 --- a/modules/material_maker/SCsub +++ b/modules/material_maker/SCsub @@ -135,6 +135,29 @@ sources = [ "nodes/gradient/radial_gradient.cpp", "nodes/gradient/gradient.cpp", "nodes/gradient/circular_gradient.cpp", + + "nodes/filter/tonality.cpp", + "nodes/filter/swap_channels.cpp", + "nodes/filter/quantize.cpp", + "nodes/filter/math.cpp", + "nodes/filter/make_tileable.cpp", + "nodes/filter/invert.cpp", + "nodes/filter/greyscale.cpp", + "nodes/filter/fill_to_uv.cpp", + "nodes/filter/fill_to_size.cpp", + "nodes/filter/fill_to_random_grey.cpp", + "nodes/filter/fill_to_random_color.cpp", + "nodes/filter/fill_to_position.cpp", + "nodes/filter/fill_to_color.cpp", + "nodes/filter/fill_channel.cpp", + "nodes/filter/emboss.cpp", + "nodes/filter/decompose.cpp", + "nodes/filter/combine.cpp", + "nodes/filter/colorize.cpp", + "nodes/filter/brightness_contrast.cpp", + "nodes/filter/blur_gaussian.cpp", + "nodes/filter/blend.cpp", + "nodes/filter/adjust_hsv.cpp", ] if env["tools"]: diff --git a/modules/material_maker/config.py b/modules/material_maker/config.py index 03a6b85cc..695ffce93 100644 --- a/modules/material_maker/config.py +++ b/modules/material_maker/config.py @@ -105,6 +105,29 @@ def get_doc_classes(): "MMRadialGradient", "MMGradient", "MMCircularGradient", + + "MMTonality", + "MMSwapChannels", + "MMQuantize", + "MMMath", + "MMMakeTileable", + "MMInvert", + "MMGreyscale", + "MMFillToUv", + "MMFillToSize", + "MMFillToRandomGrey", + "MMFillToRandomColor", + "MMFillToPosition", + "MMFillToColor", + "MMFillChannel", + "MMEmboss", + "MMDecompose", + "MMCombine", + "MMColorize", + "MMBrightnessContrast", + "MMBlurGaussian", + "MMBlend", + "MMAdjustHsv", ] def get_doc_path(): diff --git a/modules/material_maker/nodes/filter/adjust_hsv.cpp b/modules/material_maker/nodes/filter/adjust_hsv.cpp index dbbdf4f7a..67fdb3299 100644 --- a/modules/material_maker/nodes/filter/adjust_hsv.cpp +++ b/modules/material_maker/nodes/filter/adjust_hsv.cpp @@ -1,197 +1,121 @@ #include "adjust_hsv.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref AdjustHsv::get_image() { - return image; +Ref MMAdjustHsv::get_image() { + return image; } -void AdjustHsv::set_image(const Ref &val) { -image = val; +void MMAdjustHsv::set_image(const Ref &val) { + image = val; } - -Ref AdjustHsv::get_input() { - return input; +Ref MMAdjustHsv::get_input() { + return input; } -void AdjustHsv::set_input(const Ref &val) { -input = val; +void MMAdjustHsv::set_input(const Ref &val) { + input = val; } - -float AdjustHsv::get_hue() const { - return hue; +float MMAdjustHsv::get_hue() const { + return hue; } -void AdjustHsv::set_hue(const float val) { -hue = val; +void MMAdjustHsv::set_hue(const float val) { + hue = val; + set_dirty(true); } - -float AdjustHsv::get_saturation() const { - return saturation; +float MMAdjustHsv::get_saturation() const { + return saturation; } -void AdjustHsv::set_saturation(const float val) { -saturation = val; +void MMAdjustHsv::set_saturation(const float val) { + saturation = val; + set_dirty(true); } - -float AdjustHsv::get_value() const { - return value; +float MMAdjustHsv::get_value() const { + return value; } -void AdjustHsv::set_value(const float val) { -value = val; +void MMAdjustHsv::set_value(const float val) { + value = val; + set_dirty(true); } +void MMAdjustHsv::_init_properties() { + if (!input.is_valid()) { + input.instance(); + input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR); + input->set_default_value(Color(0, 0, 0, 1)); + } + input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input->set_slot_name(">>> Input1 "); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input; - //export(float) ; - float hue = 0; - //export(float) ; - float saturation = 1; - //export(float) ; - float value = 1; + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } - void AdjustHsv::_init_properties() { + //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); + //image.force_override = true; - if (!input) { - input = MMNodeUniversalProperty.new(); - input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; - input.set_default_value(Color(0, 0, 0, 1)); + register_input_property(input); + register_output_property(image); } - input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input.slot_name = ">>> Input1 "; - - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; +void MMAdjustHsv::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_label_universal(input); + mm_graph_node->add_slot_texture_universal(image); + mm_graph_node->add_slot_float("get_hue", "set_hue", "Hue", 0.01); + mm_graph_node->add_slot_float("get_saturation", "set_saturation", "Saturation", 0.01); + mm_graph_node->add_slot_float("get_value", "set_value", "Value", 0.01); } - //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - //image.force_override = true; - register_input_property(input); - register_output_property(image); +void MMAdjustHsv::_render(const Ref &material) { + Ref img = render_image(material); + image->set_value(img); } - - void AdjustHsv::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_label_universal(input); - mm_graph_node.add_slot_texture_universal(image); - mm_graph_node.add_slot_float("get_hue", "set_hue", "Hue", 0.01); - mm_graph_node.add_slot_float("get_saturation", "set_saturation", "Saturation", 0.01); - mm_graph_node.add_slot_float("get_value", "set_value", "Value", 0.01); +Color MMAdjustHsv::_get_value_for(const Vector2 &uv, const int pseed) { + Color c = input->get_value(uv); + return MMAlgos::adjust_hsv(c, hue, saturation, value); } - - void AdjustHsv::_render(const Variant &material) { - Ref img = render_image(material); - image.set_value(img); +MMAdjustHsv::MMAdjustHsv() { + hue = 0; + saturation = 1; + value = 1; } - - Color AdjustHsv::_get_value_for(const Vector2 &uv, const int pseed) { - Color c = input.get_value(uv); - return MMAlgos.adjust_hsv(c, hue, saturation, value); +MMAdjustHsv::~MMAdjustHsv() { } - //hue; +void MMAdjustHsv::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMAdjustHsv::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMAdjustHsv::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_image", "get_image"); - float AdjustHsv::get_hue() { - return hue; + ClassDB::bind_method(D_METHOD("get_input"), &MMAdjustHsv::get_input); + ClassDB::bind_method(D_METHOD("set_input", "value"), &MMAdjustHsv::set_input); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input", "get_input"); + + ClassDB::bind_method(D_METHOD("get_hue"), &MMAdjustHsv::get_hue); + ClassDB::bind_method(D_METHOD("set_hue", "value"), &MMAdjustHsv::set_hue); + ADD_PROPERTY(PropertyInfo(Variant::REAL, "hue"), "set_hue", "get_hue"); + + ClassDB::bind_method(D_METHOD("get_saturation"), &MMAdjustHsv::get_saturation); + ClassDB::bind_method(D_METHOD("set_saturation", "value"), &MMAdjustHsv::set_saturation); + ADD_PROPERTY(PropertyInfo(Variant::REAL, "saturation"), "set_saturation", "get_saturation"); + + ClassDB::bind_method(D_METHOD("get_value"), &MMAdjustHsv::get_value); + ClassDB::bind_method(D_METHOD("set_value", "value"), &MMAdjustHsv::set_value); + ADD_PROPERTY(PropertyInfo(Variant::REAL, "value"), "set_value", "get_value"); } - - - void AdjustHsv::set_hue(const float val) { - hue = val; - set_dirty(true); -} - - //saturation; - - float AdjustHsv::get_saturation() { - return saturation; -} - - - void AdjustHsv::set_saturation(const float val) { - saturation = val; - set_dirty(true); -} - - //value; - - float AdjustHsv::get_value() { - return value; -} - - - void AdjustHsv::set_value(const float val) { - value = val; - set_dirty(true); -} - -} - - AdjustHsv::AdjustHsv() { - image; - input; - hue = 0; - saturation = 1; - value = 1; - } - - AdjustHsv::~AdjustHsv() { - } - - - static void AdjustHsv::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &AdjustHsv::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &AdjustHsv::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input"), &AdjustHsv::get_input); - ClassDB::bind_method(D_METHOD("set_input", "value"), &AdjustHsv::set_input); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - - - ClassDB::bind_method(D_METHOD("get_hue"), &AdjustHsv::get_hue); - ClassDB::bind_method(D_METHOD("set_hue", "value"), &AdjustHsv::set_hue); - ADD_PROPERTY(PropertyInfo(Variant::REAL, "hue"), "set_hue", "get_hue"); - - - ClassDB::bind_method(D_METHOD("get_saturation"), &AdjustHsv::get_saturation); - ClassDB::bind_method(D_METHOD("set_saturation", "value"), &AdjustHsv::set_saturation); - ADD_PROPERTY(PropertyInfo(Variant::REAL, "saturation"), "set_saturation", "get_saturation"); - - - ClassDB::bind_method(D_METHOD("get_value"), &AdjustHsv::get_value); - ClassDB::bind_method(D_METHOD("set_value", "value"), &AdjustHsv::set_value); - ADD_PROPERTY(PropertyInfo(Variant::REAL, "value"), "set_value", "get_value"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &AdjustHsv::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &AdjustHsv::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &AdjustHsv::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &AdjustHsv::_get_value_for); - ClassDB::bind_method(D_METHOD("get_hue"), &AdjustHsv::get_hue); - ClassDB::bind_method(D_METHOD("set_hue", "val"), &AdjustHsv::set_hue); - ClassDB::bind_method(D_METHOD("get_saturation"), &AdjustHsv::get_saturation); - ClassDB::bind_method(D_METHOD("set_saturation", "val"), &AdjustHsv::set_saturation); - ClassDB::bind_method(D_METHOD("get_value"), &AdjustHsv::get_value); - ClassDB::bind_method(D_METHOD("set_value", "val"), &AdjustHsv::set_value); - - } - - - diff --git a/modules/material_maker/nodes/filter/adjust_hsv.h b/modules/material_maker/nodes/filter/adjust_hsv.h index 3c971e773..b3fc7e2d7 100644 --- a/modules/material_maker/nodes/filter/adjust_hsv.h +++ b/modules/material_maker/nodes/filter/adjust_hsv.h @@ -1,59 +1,44 @@ -#ifndef ADJUST_HSV_H -#define ADJUST_HSV_H +#ifndef MM_ADJUST_HSV_H +#define MM_ADJUST_HSV_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class AdjustHsv : public MMNode { - GDCLASS(AdjustHsv, MMNode); +class MMAdjustHsv : public MMNode { + GDCLASS(MMAdjustHsv, MMNode); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input(); + void set_input(const Ref &val); - Ref get_input(); - void set_input(const Ref &val); + float get_hue() const; + void set_hue(const float val); - float get_hue() const; - void set_hue(const float val); + float get_saturation() const; + void set_saturation(const float val); - float get_saturation() const; - void set_saturation(const float val); + float get_value() const; + void set_value(const float val); - float get_value() const; - void set_value(const float val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); - float get_hue(); - void set_hue(const float val); - float get_saturation(); - void set_saturation(const float val); - float get_value(); - void set_value(const float val); + MMAdjustHsv(); + ~MMAdjustHsv(); - AdjustHsv(); - ~AdjustHsv(); +protected: + static void _bind_methods(); - protected: - static void _bind_methods(); - - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref input; - //export(float) - float hue = 0; - //export(float) - float saturation = 1; - //export(float) - float value = 1; - //hue - //saturation - //value + Ref image; + Ref input; + float hue; + float saturation; + float value; }; - #endif diff --git a/modules/material_maker/nodes/filter/blend.cpp b/modules/material_maker/nodes/filter/blend.cpp index d10705c70..ad9803c82 100644 --- a/modules/material_maker/nodes/filter/blend.cpp +++ b/modules/material_maker/nodes/filter/blend.cpp @@ -1,257 +1,187 @@ #include "blend.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref Blend::get_image() { - return image; +Ref MMBlend::get_image() { + return image; } -void Blend::set_image(const Ref &val) { -image = val; +void MMBlend::set_image(const Ref &val) { + image = val; } - -Ref Blend::get_input1() { - return input1; +Ref MMBlend::get_input1() { + return input1; } -void Blend::set_input1(const Ref &val) { -input1 = val; +void MMBlend::set_input1(const Ref &val) { + input1 = val; } - -Ref Blend::get_input2() { - return input2; +Ref MMBlend::get_input2() { + return input2; } -void Blend::set_input2(const Ref &val) { -input2 = val; +void MMBlend::set_input2(const Ref &val) { + input2 = val; } - -int Blend::get_blend_type() const { - return blend_type; +int MMBlend::get_blend_type() const { + return blend_type; } -void Blend::set_blend_type(const int val) { -blend_type = val; +void MMBlend::set_blend_type(const int val) { + blend_type = val; + set_dirty(true); } - -Ref Blend::get_opacity() { - return opacity; +Ref MMBlend::get_opacity() { + return opacity; } -void Blend::set_opacity(const Ref &val) { -opacity = val; +void MMBlend::set_opacity(const Ref &val) { + opacity = val; } +void MMBlend::_init_properties() { + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); - //tool; - }; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input1; - //export(Resource) ; - Ref input2; - //export(int, "Normal,Dissolve,Multiply,Screen,Overlay,Hard Light,Soft Light,Burn,Dodge,Lighten,Darken,Difference") ; - int blend_type = 0; - //export(Resource) ; - Ref opacity; + if (!input1.is_valid()) { + input1.instance(); + input1->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR); + input1->set_default_value(Color(1, 1, 1, 1)); + } - void Blend::_init_properties() { + input1->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input1->set_slot_name(">>> Input1 "); - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; + if (!input2.is_valid()) { + input2.instance(); + input2->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR); + input2->set_default_value(Color(1, 1, 1, 1)); + } + + input2->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input2->set_slot_name(">>> Input2 "); + + if (!opacity.is_valid()) { + opacity.instance(); + opacity->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_FLOAT); + opacity->set_default_value(0.5); + opacity->set_value_range(Vector2(0, 1)); + opacity->set_value_step(0.01); + } + + opacity->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + opacity->set_slot_name("opacity"); + + register_input_property(input1); + register_input_property(input2); + register_output_property(image); + register_input_property(opacity); } - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; +void MMBlend::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_texture_universal(image); - if (!input1) { - input1 = MMNodeUniversalProperty.new(); - input1.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; - input1.set_default_value(Color(1, 1, 1, 1)); + Array arr; + arr.push_back("Normal"); + arr.push_back("Dissolve"); + arr.push_back("Multiply"); + arr.push_back("Screen"); + arr.push_back("Overlay"); + arr.push_back("Hard Light"); + arr.push_back("Soft Light"); + arr.push_back("Burn"); + arr.push_back("Dodge"); + arr.push_back("Lighten"); + arr.push_back("Darken"); + arr.push_back("Difference"); + + mm_graph_node->add_slot_enum("get_blend_type", "set_blend_type", "blend_type", arr); + mm_graph_node->add_slot_label_universal(input1); + mm_graph_node->add_slot_label_universal(input2); + mm_graph_node->add_slot_float_universal(opacity); } - input1.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input1.slot_name = ">>> Input1 "; - - if (!input2) { - input2 = MMNodeUniversalProperty.new(); - input2.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; - input2.set_default_value(Color(1, 1, 1, 1)); +void MMBlend::_render(const Ref &material) { + Ref img = render_image(material); + image->set_value(img); } - input2.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input2.slot_name = ">>> Input2 "; +Color MMBlend::_get_value_for(const Vector2 &uv, const int pseed) { + Vector3 b = Vector3(); + //vec4 $(name_uv)_s1 = $s1($uv); + Color s1 = input1->get_value(uv); + //vec4 $(name_uv)_s2 = $s2($uv); + Color s2 = input2->get_value(uv); + //float $(name_uv)_a = $amount*$a($uv); + float a = opacity->get_value(uv); + //vec4(blend_$blend_type($uv, $(name_uv)_s1.rgb, $(name_uv)_s2.rgb, $(name_uv)_a*$(name_uv)_s1.a), min(1.0, $(name_uv)_s2.a+$(name_uv)_a*$(name_uv)_s1.a)); + //"Normal,Dissolve,Multiply,Screen,Overlay,Hard Light,Soft Light,Burn,Dodge,Lighten,Darken,Difference"; - if (!opacity) { - opacity = MMNodeUniversalProperty.new(); - opacity.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_FLOAT; - opacity.set_default_value(0.5); - opacity.value_range = Vector2(0, 1); - opacity.value_step = 0.01; + if (blend_type == BLEND_TYPE_NORMAL) { + b = MMAlgos::blend_normal(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); + } else if (blend_type == BLEND_TYPE_DISSOLVE) { + b = MMAlgos::blend_dissolve(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); + } else if (blend_type == BLEND_TYPE_MULTIPLY) { + b = MMAlgos::blend_multiply(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); + } else if (blend_type == BLEND_TYPE_SCREEN) { + b = MMAlgos::blend_screen(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); + } else if (blend_type == BLEND_TYPE_OVERLAY) { + b = MMAlgos::blend_overlay(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); + } else if (blend_type == BLEND_TYPE_HARD_LIGHT) { + b = MMAlgos::blend_hard_light(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); + } else if (blend_type == BLEND_TYPE_SOFT_LIGHT) { + b = MMAlgos::blend_soft_light(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); + } else if (blend_type == BLEND_TYPE_BURN) { + b = MMAlgos::blend_burn(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); + } else if (blend_type == BLEND_TYPE_DODGE) { + b = MMAlgos::blend_dodge(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); + } else if (blend_type == BLEND_TYPE_LIGHTEN) { + b = MMAlgos::blend_lighten(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); + } else if (blend_type == BLEND_TYPE_DARKEN) { + b = MMAlgos::blend_darken(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); + } else if (blend_type == BLEND_TYPE_DIFFRENCE) { + b = MMAlgos::blend_difference(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); + } + + return Color(b.x, b.y, b.z, MIN(1, s2.a + a * s1.a)); } - opacity.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - opacity.slot_name = "opacity"; - register_input_property(input1); - register_input_property(input2); - register_output_property(image); - register_input_property(opacity); +MMBlend::MMBlend() { + blend_type = 0; } - - void Blend::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_texture_universal(image); - mm_graph_node.add_slot_enum("get_blend_type", "set_blend_type", "blend_type", [ "Normal", "Dissolve", "Multiply", "Screen", "Overlay", "Hard Light", "Soft Light", "Burn", "Dodge", "Lighten", "Darken", "Difference" ]); - mm_graph_node.add_slot_label_universal(input1); - mm_graph_node.add_slot_label_universal(input2); - mm_graph_node.add_slot_float_universal(opacity); +MMBlend::~MMBlend() { } +void MMBlend::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMBlend::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMBlend::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_image", "get_image"); - void Blend::_render(const Variant &material) { - Ref img = render_image(material); - image.set_value(img); + ClassDB::bind_method(D_METHOD("get_input1"), &MMBlend::get_input1); + ClassDB::bind_method(D_METHOD("set_input1", "value"), &MMBlend::set_input1); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input1", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input1", "get_input1"); + + ClassDB::bind_method(D_METHOD("get_input2"), &MMBlend::get_input2); + ClassDB::bind_method(D_METHOD("set_input2", "value"), &MMBlend::set_input2); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input2", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input2", "get_input2"); + + ClassDB::bind_method(D_METHOD("get_blend_type"), &MMBlend::get_blend_type); + ClassDB::bind_method(D_METHOD("set_blend_type", "value"), &MMBlend::set_blend_type); + ADD_PROPERTY(PropertyInfo(Variant::INT, "blend_type"), "set_blend_type", "get_blend_type"); + + ClassDB::bind_method(D_METHOD("get_opacity"), &MMBlend::get_opacity); + ClassDB::bind_method(D_METHOD("set_opacity", "value"), &MMBlend::set_opacity); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "opacity", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_opacity", "get_opacity"); } - - - Color Blend::_get_value_for(const Vector2 &uv, const int pseed) { - Vector3 b = Vector3(); - //vec4 $(name_uv)_s1 = $s1($uv); - Color s1 = input1.get_value(uv); - //vec4 $(name_uv)_s2 = $s2($uv); - Color s2 = input2.get_value(uv); - //float $(name_uv)_a = $amount*$a($uv); - float a = opacity.get_value(uv); - //vec4(blend_$blend_type($uv, $(name_uv)_s1.rgb, $(name_uv)_s2.rgb, $(name_uv)_a*$(name_uv)_s1.a), min(1.0, $(name_uv)_s2.a+$(name_uv)_a*$(name_uv)_s1.a)); - //"Normal,Dissolve,Multiply,Screen,Overlay,Hard Light,Soft Light,Burn,Dodge,Lighten,Darken,Difference"; - - if (blend_type == BlendType.NORMAL) { - b = MMAlgos.blend_normal(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); -} - - - else if (blend_type == BlendType.DISSOLVE) { - b = MMAlgos.blend_dissolve(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); -} - - - else if (blend_type == BlendType.MULTIPLY) { - b = MMAlgos.blend_multiply(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); -} - - - else if (blend_type == BlendType.SCREEN) { - b = MMAlgos.blend_screen(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); -} - - - else if (blend_type == BlendType.OVERLAY) { - b = MMAlgos.blend_overlay(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); -} - - - else if (blend_type == BlendType.HARD_LIGHT) { - b = MMAlgos.blend_hard_light(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); -} - - - else if (blend_type == BlendType.SOFT_LIGHT) { - b = MMAlgos.blend_soft_light(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); -} - - - else if (blend_type == BlendType.BURN) { - b = MMAlgos.blend_burn(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); -} - - - else if (blend_type == BlendType.DODGE) { - b = MMAlgos.blend_dodge(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); -} - - - else if (blend_type == BlendType.LIGHTEN) { - b = MMAlgos.blend_lighten(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); -} - - - else if (blend_type == BlendType.DARKEN) { - b = MMAlgos.blend_darken(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); -} - - - else if (blend_type == BlendType.DIFFRENCE) { - b = MMAlgos.blend_difference(uv, Vector3(s1.r, s1.g, s1.b), Vector3(s2.r, s2.g, s2.b), a * s1.a); -} - - return Color(b.x, b.y, b.z, min(1, s2.a + a * s1.a)); -} - - - int Blend::get_blend_type() { - return blend_type; -} - - - void Blend::set_blend_type(const int val) { - blend_type = val; - set_dirty(true); -} - -} - - Blend::Blend() { - image; - input1; - input2; - blend_type = 0; - opacity; - } - - Blend::~Blend() { - } - - - static void Blend::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &Blend::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &Blend::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input1"), &Blend::get_input1); - ClassDB::bind_method(D_METHOD("set_input1", "value"), &Blend::set_input1); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input1", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input1", "get_input1"); - - - ClassDB::bind_method(D_METHOD("get_input2"), &Blend::get_input2); - ClassDB::bind_method(D_METHOD("set_input2", "value"), &Blend::set_input2); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input2", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input2", "get_input2"); - - - ClassDB::bind_method(D_METHOD("get_blend_type"), &Blend::get_blend_type); - ClassDB::bind_method(D_METHOD("set_blend_type", "value"), &Blend::set_blend_type); - ADD_PROPERTY(PropertyInfo(Variant::INT, "blend_type"), "set_blend_type", "get_blend_type"); - - - ClassDB::bind_method(D_METHOD("get_opacity"), &Blend::get_opacity); - ClassDB::bind_method(D_METHOD("set_opacity", "value"), &Blend::set_opacity); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "opacity", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_opacity", "get_opacity"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &Blend::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &Blend::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &Blend::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &Blend::_get_value_for); - ClassDB::bind_method(D_METHOD("get_blend_type"), &Blend::get_blend_type); - ClassDB::bind_method(D_METHOD("set_blend_type", "val"), &Blend::set_blend_type); - - } - - - diff --git a/modules/material_maker/nodes/filter/blend.h b/modules/material_maker/nodes/filter/blend.h index 6d322b95b..c74b10a74 100644 --- a/modules/material_maker/nodes/filter/blend.h +++ b/modules/material_maker/nodes/filter/blend.h @@ -1,69 +1,60 @@ -#ifndef BLEND_H -#define BLEND_H +#ifndef MM_BLEND_H +#define MM_BLEND_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class Blend : public MMNode { - GDCLASS(Blend, MMNode); +class MMBlend : public MMNode { + GDCLASS(MMBlend, MMNode); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input1(); + void set_input1(const Ref &val); - Ref get_input1(); - void set_input1(const Ref &val); + Ref get_input2(); + void set_input2(const Ref &val); - Ref get_input2(); - void set_input2(const Ref &val); + int get_blend_type() const; + void set_blend_type(const int val); - int get_blend_type() const; - void set_blend_type(const int val); + Ref get_opacity(); + void set_opacity(const Ref &val); - Ref get_opacity(); - void set_opacity(const Ref &val); + enum MMBlendType { + BLEND_TYPE_NORMAL = 0, + BLEND_TYPE_DISSOLVE, + BLEND_TYPE_MULTIPLY, + BLEND_TYPE_SCREEN, + BLEND_TYPE_OVERLAY, + BLEND_TYPE_HARD_LIGHT, + BLEND_TYPE_SOFT_LIGHT, + BLEND_TYPE_BURN, + BLEND_TYPE_DODGE, + BLEND_TYPE_LIGHTEN, + BLEND_TYPE_DARKEN, + BLEND_TYPE_DIFFRENCE + }; - enum BlendType { + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); - NORMAL = 0, - DISSOLVE, - MULTIPLY, - SCREEN, - OVERLAY, - HARD_LIGHT, - SOFT_LIGHT, - BURN, - DODGE, - LIGHTEN, - DARKEN, - DIFFRENCE + MMBlend(); + ~MMBlend(); + +protected: + static void _bind_methods(); + + Ref image; + Ref input1; + Ref input2; + //export(int, "Normal,Dissolve,Multiply,Screen,Overlay,Hard Light,Soft Light,Burn,Dodge,Lighten,Darken,Difference") + int blend_type; + Ref opacity; }; - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); - int get_blend_type(); - void set_blend_type(const int val); - - Blend(); - ~Blend(); - - protected: - static void _bind_methods(); - - //tool - }; - //export(Resource) - Ref image; - //export(Resource) - Ref input1; - //export(Resource) - Ref input2; - //export(int, "Normal,Dissolve,Multiply,Screen,Overlay,Hard Light,Soft Light,Burn,Dodge,Lighten,Darken,Difference") - int blend_type = 0; - //export(Resource) - Ref opacity; -}; - - #endif diff --git a/modules/material_maker/nodes/filter/blur_gaussian.cpp b/modules/material_maker/nodes/filter/blur_gaussian.cpp index 0957687e1..b8e7e77b2 100644 --- a/modules/material_maker/nodes/filter/blur_gaussian.cpp +++ b/modules/material_maker/nodes/filter/blur_gaussian.cpp @@ -1,362 +1,314 @@ #include "blur_gaussian.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref BlurGaussian::get_image() { - return image; +Ref MMBlurGaussian::get_image() { + return image; } -void BlurGaussian::set_image(const Ref &val) { -image = val; +void MMBlurGaussian::set_image(const Ref &val) { + image = val; } - -Ref BlurGaussian::get_input() { - return input; +Ref MMBlurGaussian::get_input() { + return input; } -void BlurGaussian::set_input(const Ref &val) { -input = val; +void MMBlurGaussian::set_input(const Ref &val) { + input = val; } - -Ref BlurGaussian::get_sigma() { - return sigma; +Ref MMBlurGaussian::get_sigma() { + return sigma; } -void BlurGaussian::set_sigma(const Ref &val) { -sigma = val; +void MMBlurGaussian::set_sigma(const Ref &val) { + sigma = val; } - -int BlurGaussian::get_direction() const { - return direction; +int MMBlurGaussian::get_direction() const { + return direction; } -void BlurGaussian::set_direction(const int val) { -direction = val; +void MMBlurGaussian::set_direction(const int val) { + direction = val; + set_dirty(true); } - -int BlurGaussian::get_size() const { - return size; +int MMBlurGaussian::get_size() const { + return size; } -void BlurGaussian::set_size(const int val) { -size = val; +void MMBlurGaussian::set_size(const int val) { + size = val; + set_dirty(true); } +void MMBlurGaussian::_init_properties() { + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input; - //export(Resource) ; - Ref sigma; - //export(int, "Both,X,Y") ; - int direction = 0; - int size = 0; + if (!input.is_valid()) { + input.instance(); + input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR); + input->set_default_value(Color()); + } - void BlurGaussian::_init_properties() { + input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input->set_slot_name(">>> Input1 "); - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; + if (!sigma.is_valid()) { + sigma.instance(); + sigma->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_FLOAT); + sigma->set_default_value(50); + } + + sigma->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + sigma->set_slot_name("Sigma"); + + register_input_property(input); + register_output_property(image); + register_input_property(sigma); } - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; +void MMBlurGaussian::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_texture_universal(image); + mm_graph_node->add_slot_label_universal(input); + mm_graph_node->add_slot_int_universal(sigma); - if (!input) { - input = MMNodeUniversalProperty.new(); - input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; - input.set_default_value(Color()); + Array arr; + arr.push_back("Both"); + arr.push_back("X"); + arr.push_back("Y"); + + mm_graph_node->add_slot_enum("get_direction", "set_direction", "Direction", arr); } - input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input.slot_name = ">>> Input1 "; - - if (!sigma) { - sigma = MMNodeUniversalProperty.new(); - sigma.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_FLOAT; - sigma.set_default_value(50); +void MMBlurGaussian::_render(const Ref &material) { + size = MAX(material->image_size.x, material->image_size.y); + Ref img = render_image(material); + image->set_value(img); } - sigma.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - sigma.slot_name = "Sigma"; - register_input_property(input); - register_output_property(image); - register_input_property(sigma); +Ref MMBlurGaussian::_render_image(const Ref &material) { + Ref img; + img.instance(); + + img->create(material->image_size.x, material->image_size.y, false, Image::FORMAT_RGBA8); + img->lock(); + + float w = img->get_width(); + float h = img->get_width(); + float pseed = Math::randf() + Math::rand(); + + if (direction == 0) { + for (int x = 0; x < img->get_width(); ++x) { //x in range(img.get_width()) + + for (int y = 0; y < img->get_height(); ++y) { //y in range(img.get_height()) + Vector2 v = Vector2(x / w, y / h); + Color col = get_value_x(v, pseed); + img->set_pixel(x, y, col); + } + } + + img->unlock(); + image->set_value(img); + + Ref image2; + image2.instance(); + + image2->create(material->image_size.x, material->image_size.y, false, Image::FORMAT_RGBA8); + image2->lock(); + + for (int x = 0; x < img->get_width(); ++x) { //x in range(img.get_width()) + for (int y = 0; y < img->get_height(); ++y) { //y in range(img.get_height()) + Vector2 v = Vector2(x / w, y / h); + Color col = get_value_y_img(v, pseed); + image2->set_pixel(x, y, col); + } + } + + image2->unlock(); + + return image2; + } + + if (direction == 1) { + for (int x = 0; x < img->get_width(); ++x) { //x in range(img.get_width()) + + for (int y = 0; y < img->get_height(); ++y) { //y in range(img.get_height()) + Vector2 v = Vector2(x / w, y / h); + Color col = get_value_x(v, pseed); + img->set_pixel(x, y, col); + } + } + } + + if (direction == 2) { + for (int x = 0; x < img->get_width(); ++x) { //x in range(img.get_width()) + + for (int y = 0; y < img->get_height(); ++y) { //y in range(img.get_height()) + Vector2 v = Vector2(x / w, y / h); + Color col = get_value_y(v, pseed); + img->set_pixel(x, y, col); + } + } + } + + img->unlock(); + + return img; } - - void BlurGaussian::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_texture_universal(image); - mm_graph_node.add_slot_label_universal(input); - mm_graph_node.add_slot_int_universal(sigma); - mm_graph_node.add_slot_enum("get_direction", "set_direction", "Direction", [ "Both", "X", "Y" ]); +Color MMBlurGaussian::get_value_x(const Vector2 &uv, const int pseed) { + float sig_def = sigma->get_default_value(uv); + float sig = sigma->get_value(uv); + return gaussian_blur_x(uv, size, sig_def, sig); } - - void BlurGaussian::_render(const Variant &material) { - size = max(material.image_size.x, material.image_size.y); - Ref img = render_image(material); - image.set_value(img); +Color MMBlurGaussian::get_value_y(const Vector2 &uv, const int pseed) { + float sig_def = sigma->get_default_value(uv); + float sig = sigma->get_value(uv); + return gaussian_blur_y(uv, size, sig_def, sig); } - - Image BlurGaussian::_render_image(const Variant &material) { - Ref img = Image.new(); - img.create(material.image_size.x, material.image_size.y, false, Image.FORMAT_RGBA8); - img.lock(); - float w = img.get_width(); - float h = img.get_width(); - float pseed = randf() + randi(); - - if (direction == 0) { - - for (int x = 0; x < img.get_width(); ++x) { //x in range(img.get_width()) - - for (int y = 0; y < img.get_height(); ++y) { //y in range(img.get_height()) - Vector2 v = Vector2(x / w, y / h); - Color col = get_value_x(v, pseed); - img.set_pixel(x, y, col); +Color MMBlurGaussian::get_value_y_img(const Vector2 &uv, const int pseed) { + float sig_def = sigma->get_default_value(uv); + float sig = sigma->get_value(uv); + return gaussian_blur_y_img(uv, size, sig_def, sig); } +//----------------------; +//gaussian_blur_x.mmg; +//vec4 $(name)_fct(vec2 uv) {; +// float e = 1.0 / $size; +// vec4 rv = vec4(0.0); +// float sum = 0.0; +// float sigma = max(0.000001, $sigma * $amount(uv)); +//; +// for (float i = -50.0; i <= 50.0; i += 1.0) {; +// float coef = exp(-0.5 * (pow(i / sigma, 2.0))) / (6.28318530718 * sigma * sigma); +// rv += $in(uv+vec2(i*e, 0.0))*coef; +// sum += coef; +// }; +//; +// return rv/sum; +//}; + +Color MMBlurGaussian::gaussian_blur_x(const Vector2 &uv, const float psize, const float psigma, const float pamount) { + float e = 1.0 / psize; + Color rv = Color(); + float sum = 0.0; + //pamount(uv)); + float sigma = MAX(0.000001, psigma * pamount); + float i = -50; + //for (float i = -50.0; i <= 50.0; i += 1.0) {; + + while (i <= 50) { + float coef = exp(-0.5 * (pow(i / sigma, 2.0))) / (6.28318530718 * sigma * sigma); + rv += Color(input->get_value(uv + Vector2(i * e, 0.0))) * coef; + sum += coef; + i += 1; + } + + return rv / sum; } - img.unlock(); - image.set_value(img); - Ref image2 = Image.new(); - image2.create(material.image_size.x, material.image_size.y, false, Image.FORMAT_RGBA8); - image2.lock(); +//----------------------; +//gaussian_blur_y.mmg; +//vec4 $(name)_fct(vec2 uv) {; +// float e = 1.0/$size; +// vec4 rv = vec4(0.0); +// float sum = 0.0; +// float sigma = max(0.000001, $sigma*$amount(uv)); +// for (float i = -50.0; i <= 50.0; i += 1.0) {; +// float coef = exp(-0.5 * (pow(i / sigma, 2.0))) / (6.28318530718*sigma*sigma); +// rv += $in(uv+vec2(0.0, i*e))*coef; +// sum += coef; +// }; +//; +// return rv/sum; +//}; - for (int x = 0; x < img.get_width(); ++x) { //x in range(img.get_width()) +Color MMBlurGaussian::gaussian_blur_y(const Vector2 &uv, const float psize, const float psigma, const float pamount) { + float e = 1.0 / psize; + Color rv = Color(); + float sum = 0.0; + //pamount(uv)); + float sigma = MAX(0.000001, psigma * pamount); + float i = -50; + //for (float i = -50.0; i <= 50.0; i += 1.0) {; - for (int y = 0; y < img.get_height(); ++y) { //y in range(img.get_height()) - Vector2 v = Vector2(x / w, y / h); - Color col = get_value_y_img(v, pseed); - image2.set_pixel(x, y, col); + while (i <= 50) { + float coef = exp(-0.5 * (pow(i / sigma, 2.0))) / (6.28318530718 * sigma * sigma); + rv += Color(input->get_value(uv + Vector2(0.0, i * e))) * coef; + sum += coef; + i += 1; + } + + return rv / sum; } +Color MMBlurGaussian::gaussian_blur_y_img(const Vector2 &uv, const float psize, const float psigma, const float pamount) { + float e = 1.0 / psize; + Color rv = Color(); + float sum = 0.0; + //pamount(uv)); + float sigma = MAX(0.000001, psigma * pamount); + float i = -50; + //for (float i = -50.0; i <= 50.0; i += 1.0) {; + + while (i <= 50) { + float coef = exp(-0.5 * (pow(i / sigma, 2.0))) / (6.28318530718 * sigma * sigma); + rv += Color(image->get_value(uv + Vector2(0.0, i * e))) * coef; + sum += coef; + i += 1; + } + + return rv / sum; } - image2.unlock(); - return image2; +MMBlurGaussian::MMBlurGaussian() { + direction = 0; + size = 0; } - - if (direction == 1) { - - for (int x = 0; x < img.get_width(); ++x) { //x in range(img.get_width()) - - for (int y = 0; y < img.get_height(); ++y) { //y in range(img.get_height()) - Vector2 v = Vector2(x / w, y / h); - Color col = get_value_x(v, pseed); - img.set_pixel(x, y, col); +MMBlurGaussian::~MMBlurGaussian() { } +void MMBlurGaussian::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMBlurGaussian::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMBlurGaussian::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_image", "get_image"); + + ClassDB::bind_method(D_METHOD("get_input"), &MMBlurGaussian::get_input); + ClassDB::bind_method(D_METHOD("set_input", "value"), &MMBlurGaussian::set_input); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input", "get_input"); + + ClassDB::bind_method(D_METHOD("get_sigma"), &MMBlurGaussian::get_sigma); + ClassDB::bind_method(D_METHOD("set_sigma", "value"), &MMBlurGaussian::set_sigma); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "sigma", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_sigma", "get_sigma"); + + ClassDB::bind_method(D_METHOD("get_direction"), &MMBlurGaussian::get_direction); + ClassDB::bind_method(D_METHOD("set_direction", "value"), &MMBlurGaussian::set_direction); + ADD_PROPERTY(PropertyInfo(Variant::INT, "direction"), "set_direction", "get_direction"); + + ClassDB::bind_method(D_METHOD("get_size"), &MMBlurGaussian::get_size); + ClassDB::bind_method(D_METHOD("set_size", "value"), &MMBlurGaussian::set_size); + ADD_PROPERTY(PropertyInfo(Variant::INT, "size"), "set_size", "get_size"); + + ClassDB::bind_method(D_METHOD("get_value_x", "uv", "pseed"), &MMBlurGaussian::get_value_x); + ClassDB::bind_method(D_METHOD("get_value_y", "uv", "pseed"), &MMBlurGaussian::get_value_y); + ClassDB::bind_method(D_METHOD("get_value_y_img", "uv", "pseed"), &MMBlurGaussian::get_value_y_img); + + ClassDB::bind_method(D_METHOD("gaussian_blur_x", "uv", "psize", "psigma", "pamount"), &MMBlurGaussian::gaussian_blur_x); + ClassDB::bind_method(D_METHOD("gaussian_blur_y", "uv", "psize", "psigma", "pamount"), &MMBlurGaussian::gaussian_blur_y); + ClassDB::bind_method(D_METHOD("gaussian_blur_y_img", "uv", "psize", "psigma", "pamount"), &MMBlurGaussian::gaussian_blur_y_img); } - -} - - - if (direction == 2) { - - for (int x = 0; x < img.get_width(); ++x) { //x in range(img.get_width()) - - for (int y = 0; y < img.get_height(); ++y) { //y in range(img.get_height()) - Vector2 v = Vector2(x / w, y / h); - Color col = get_value_y(v, pseed); - img.set_pixel(x, y, col); -} - -} - -} - - img.unlock(); - return img; -} - - - Color BlurGaussian::get_value_x(const Vector2 &uv, const int pseed) { - float sig_def = sigma.get_default_value(uv); - float sig = sigma.get_value(uv); - return gaussian_blur_x(uv, size, sig_def, sig); -} - - - Color BlurGaussian::get_value_y(const Vector2 &uv, const int pseed) { - float sig_def = sigma.get_default_value(uv); - float sig = sigma.get_value(uv); - return gaussian_blur_y(uv, size, sig_def, sig); -} - - - Color BlurGaussian::get_value_y_img(const Vector2 &uv, const int pseed) { - float sig_def = sigma.get_default_value(uv); - float sig = sigma.get_value(uv); - return gaussian_blur_y_img(uv, size, sig_def, sig); -} - - - int BlurGaussian::get_direction() { - return direction; -} - - - void BlurGaussian::set_direction(const int val) { - direction = val; - set_dirty(true); -} - - //----------------------; - //gaussian_blur_x.mmg; - //vec4 $(name)_fct(vec2 uv) {; - // float e = 1.0 / $size; - // vec4 rv = vec4(0.0); - // float sum = 0.0; - // float sigma = max(0.000001, $sigma * $amount(uv)); - //; - // for (float i = -50.0; i <= 50.0; i += 1.0) {; - // float coef = exp(-0.5 * (pow(i / sigma, 2.0))) / (6.28318530718 * sigma * sigma); - // rv += $in(uv+vec2(i*e, 0.0))*coef; - // sum += coef; - // }; - //; - // return rv/sum; - //}; - - Color BlurGaussian::gaussian_blur_x(const Vector2 &uv, const float psize, const float psigma, const float pamount) { - float e = 1.0 / psize; - Color rv = Color(); - float sum = 0.0; - //pamount(uv)); - float sigma = max(0.000001, psigma * pamount); - float i = -50; - //for (float i = -50.0; i <= 50.0; i += 1.0) {; - - while (i <= 50) { - float coef = exp(-0.5 * (pow(i / sigma, 2.0))) / (6.28318530718 * sigma * sigma); - rv += input.get_value(uv + Vector2(i*e, 0.0)) * coef; - sum += coef; - i += 1; -} - - return rv / sum; -} - - //----------------------; - //gaussian_blur_y.mmg; - //vec4 $(name)_fct(vec2 uv) {; - // float e = 1.0/$size; - // vec4 rv = vec4(0.0); - // float sum = 0.0; - // float sigma = max(0.000001, $sigma*$amount(uv)); - // for (float i = -50.0; i <= 50.0; i += 1.0) {; - // float coef = exp(-0.5 * (pow(i / sigma, 2.0))) / (6.28318530718*sigma*sigma); - // rv += $in(uv+vec2(0.0, i*e))*coef; - // sum += coef; - // }; - //; - // return rv/sum; - //}; - - Color BlurGaussian::gaussian_blur_y(const Vector2 &uv, const float psize, const float psigma, const float pamount) { - float e = 1.0 / psize; - Color rv = Color(); - float sum = 0.0; - //pamount(uv)); - float sigma = max(0.000001, psigma * pamount); - float i = -50; - //for (float i = -50.0; i <= 50.0; i += 1.0) {; - - while (i <= 50) { - float coef = exp(-0.5 * (pow(i / sigma, 2.0))) / (6.28318530718 * sigma * sigma); - rv += input.get_value(uv + Vector2(0.0, i * e)) * coef; - sum += coef; - i += 1; -} - - return rv / sum; -} - - - Color BlurGaussian::gaussian_blur_y_img(const Vector2 &uv, const float psize, const float psigma, const float pamount) { - float e = 1.0 / psize; - Color rv = Color(); - float sum = 0.0; - //pamount(uv)); - float sigma = max(0.000001, psigma * pamount); - float i = -50; - //for (float i = -50.0; i <= 50.0; i += 1.0) {; - - while (i <= 50) { - float coef = exp(-0.5 * (pow(i / sigma, 2.0))) / (6.28318530718 * sigma * sigma); - rv += image.get_value(uv + Vector2(0.0, i * e)) * coef; - sum += coef; - i += 1; -} - - return rv / sum; -} - -} - - BlurGaussian::BlurGaussian() { - image; - input; - sigma; - direction = 0; - size = 0; - } - - BlurGaussian::~BlurGaussian() { - } - - - static void BlurGaussian::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &BlurGaussian::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &BlurGaussian::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input"), &BlurGaussian::get_input); - ClassDB::bind_method(D_METHOD("set_input", "value"), &BlurGaussian::set_input); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - - - ClassDB::bind_method(D_METHOD("get_sigma"), &BlurGaussian::get_sigma); - ClassDB::bind_method(D_METHOD("set_sigma", "value"), &BlurGaussian::set_sigma); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "sigma", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_sigma", "get_sigma"); - - - ClassDB::bind_method(D_METHOD("get_direction"), &BlurGaussian::get_direction); - ClassDB::bind_method(D_METHOD("set_direction", "value"), &BlurGaussian::set_direction); - ADD_PROPERTY(PropertyInfo(Variant::INT, "direction"), "set_direction", "get_direction"); - - - ClassDB::bind_method(D_METHOD("get_size"), &BlurGaussian::get_size); - ClassDB::bind_method(D_METHOD("set_size", "value"), &BlurGaussian::set_size); - ADD_PROPERTY(PropertyInfo(Variant::INT, "size"), "set_size", "get_size"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &BlurGaussian::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &BlurGaussian::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &BlurGaussian::_render); - ClassDB::bind_method(D_METHOD("_render_image", "material"), &BlurGaussian::_render_image); - ClassDB::bind_method(D_METHOD("get_value_x", "uv", "pseed"), &BlurGaussian::get_value_x); - ClassDB::bind_method(D_METHOD("get_value_y", "uv", "pseed"), &BlurGaussian::get_value_y); - ClassDB::bind_method(D_METHOD("get_value_y_img", "uv", "pseed"), &BlurGaussian::get_value_y_img); - ClassDB::bind_method(D_METHOD("get_direction"), &BlurGaussian::get_direction); - ClassDB::bind_method(D_METHOD("set_direction", "val"), &BlurGaussian::set_direction); - ClassDB::bind_method(D_METHOD("gaussian_blur_x", "uv", "psize", "psigma", "pamount"), &BlurGaussian::gaussian_blur_x); - ClassDB::bind_method(D_METHOD("gaussian_blur_y", "uv", "psize", "psigma", "pamount"), &BlurGaussian::gaussian_blur_y); - ClassDB::bind_method(D_METHOD("gaussian_blur_y_img", "uv", "psize", "psigma", "pamount"), &BlurGaussian::gaussian_blur_y_img); - - } - - - diff --git a/modules/material_maker/nodes/filter/blur_gaussian.h b/modules/material_maker/nodes/filter/blur_gaussian.h index 49f5bcba3..844d4ad56 100644 --- a/modules/material_maker/nodes/filter/blur_gaussian.h +++ b/modules/material_maker/nodes/filter/blur_gaussian.h @@ -1,88 +1,53 @@ -#ifndef BLUR_GAUSSIAN_H -#define BLUR_GAUSSIAN_H +#ifndef MM_BLUR_GAUSSIAN_H +#define MM_BLUR_GAUSSIAN_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class BlurGaussian : public MMNode { - GDCLASS(BlurGaussian, MMNode); +class MMBlurGaussian : public MMNode { + GDCLASS(MMBlurGaussian, MMNode); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input(); + void set_input(const Ref &val); - Ref get_input(); - void set_input(const Ref &val); + Ref get_sigma(); + void set_sigma(const Ref &val); - Ref get_sigma(); - void set_sigma(const Ref &val); + int get_direction() const; + void set_direction(const int val); - int get_direction() const; - void set_direction(const int val); + int get_size() const; + void set_size(const int val); - int get_size() const; - void set_size(const int val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Ref _render_image(const Ref &material); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Image _render_image(const Variant &material); - Color get_value_x(const Vector2 &uv, const int pseed); - Color get_value_y(const Vector2 &uv, const int pseed); - Color get_value_y_img(const Vector2 &uv, const int pseed); - int get_direction(); - void set_direction(const int val); - Color gaussian_blur_x(const Vector2 &uv, const float psize, const float psigma, const float pamount); - Color gaussian_blur_y(const Vector2 &uv, const float psize, const float psigma, const float pamount); - Color gaussian_blur_y_img(const Vector2 &uv, const float psize, const float psigma, const float pamount); + Color get_value_x(const Vector2 &uv, const int pseed); + Color get_value_y(const Vector2 &uv, const int pseed); + Color get_value_y_img(const Vector2 &uv, const int pseed); - BlurGaussian(); - ~BlurGaussian(); + Color gaussian_blur_x(const Vector2 &uv, const float psize, const float psigma, const float pamount); + Color gaussian_blur_y(const Vector2 &uv, const float psize, const float psigma, const float pamount); + Color gaussian_blur_y_img(const Vector2 &uv, const float psize, const float psigma, const float pamount); - protected: - static void _bind_methods(); + MMBlurGaussian(); + ~MMBlurGaussian(); - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref input; - //export(Resource) - Ref sigma; - //export(int, "Both,X,Y") - int direction = 0; - int size = 0; - //---------------------- - //gaussian_blur_x.mmg - //vec4 $(name)_fct(vec2 uv) { - // float e = 1.0 / $size; - // vec4 rv = vec4(0.0); - // float sum = 0.0; - // float sigma = max(0.000001, $sigma * $amount(uv)); - // - // for (float i = -50.0; i <= 50.0; i += 1.0) { - // float coef = exp(-0.5 * (pow(i / sigma, 2.0))) / (6.28318530718 * sigma * sigma); - // rv += $in(uv+vec2(i*e, 0.0))*coef; - // sum += coef; - // } - // - // return rv/sum; - //} - //---------------------- - //gaussian_blur_y.mmg - //vec4 $(name)_fct(vec2 uv) { - // float e = 1.0/$size; - // vec4 rv = vec4(0.0); - // float sum = 0.0; - // float sigma = max(0.000001, $sigma*$amount(uv)); - // for (float i = -50.0; i <= 50.0; i += 1.0) { - // float coef = exp(-0.5 * (pow(i / sigma, 2.0))) / (6.28318530718*sigma*sigma); - // rv += $in(uv+vec2(0.0, i*e))*coef; - // sum += coef; - // } - // - // return rv/sum; - //} +protected: + static void _bind_methods(); + + Ref image; + Ref input; + Ref sigma; + //export(int, "Both,X,Y") + int direction; + int size; }; - #endif diff --git a/modules/material_maker/nodes/filter/brightness_contrast.cpp b/modules/material_maker/nodes/filter/brightness_contrast.cpp index c05aecc8b..820fc7c6f 100644 --- a/modules/material_maker/nodes/filter/brightness_contrast.cpp +++ b/modules/material_maker/nodes/filter/brightness_contrast.cpp @@ -1,165 +1,106 @@ #include "brightness_contrast.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref BrightnessContrast::get_image() { - return image; +Ref MMBrightnessContrast::get_image() { + return image; } -void BrightnessContrast::set_image(const Ref &val) { -image = val; +void MMBrightnessContrast::set_image(const Ref &val) { + image = val; } - -Ref BrightnessContrast::get_input() { - return input; +Ref MMBrightnessContrast::get_input() { + return input; } -void BrightnessContrast::set_input(const Ref &val) { -input = val; +void MMBrightnessContrast::set_input(const Ref &val) { + input = val; } - -float BrightnessContrast::get_brightness() const { - return brightness; +float MMBrightnessContrast::get_brightness() const { + return brightness; } -void BrightnessContrast::set_brightness(const float val) { -brightness = val; +void MMBrightnessContrast::set_brightness(const float val) { + brightness = val; + set_dirty(true); } - -float BrightnessContrast::get_contrast() const { - return contrast; +float MMBrightnessContrast::get_contrast() const { + return contrast; } -void BrightnessContrast::set_contrast(const float val) { -contrast = val; +void MMBrightnessContrast::set_contrast(const float val) { + contrast = val; + set_dirty(true); } +void MMBrightnessContrast::_init_properties() { + if (!input.is_valid()) { + input.instance(); + input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR); + input->set_default_value(Color(0, 0, 0, 1)); + } + input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input->set_slot_name(">>> Input1 "); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input; - //export(float) ; - float brightness = 0; - //export(float) ; - float contrast = 1; + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } - void BrightnessContrast::_init_properties() { + //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); + //image.force_override = true; - if (!input) { - input = MMNodeUniversalProperty.new(); - input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; - input.set_default_value(Color(0, 0, 0, 1)); + register_input_property(input); + register_output_property(image); } - input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input.slot_name = ">>> Input1 "; - - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; +void MMBrightnessContrast::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_label_universal(input); + mm_graph_node->add_slot_texture_universal(image); + mm_graph_node->add_slot_float("get_brightness", "set_brightness", "Brightness", 0.01); + mm_graph_node->add_slot_float("get_contrast", "set_contrast", "Contrast", 0.01); } - //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - //image.force_override = true; - register_input_property(input); - register_output_property(image); +void MMBrightnessContrast::_render(const Ref &material) { + Ref img = render_image(material); + image->set_value(img); } - - void BrightnessContrast::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_label_universal(input); - mm_graph_node.add_slot_texture_universal(image); - mm_graph_node.add_slot_float("get_brightness", "set_brightness", "Brightness", 0.01); - mm_graph_node.add_slot_float("get_contrast", "set_contrast", "Contrast", 0.01); +Color MMBrightnessContrast::_get_value_for(const Vector2 &uv, const int pseed) { + Color c = input->get_value(uv); + return MMAlgos::brightness_contrast(c, brightness, contrast); } - - void BrightnessContrast::_render(const Variant &material) { - Ref img = render_image(material); - image.set_value(img); +MMBrightnessContrast::MMBrightnessContrast() { + brightness = 0; + contrast = 1; } - - Color BrightnessContrast::_get_value_for(const Vector2 &uv, const int pseed) { - Color c = input.get_value(uv); - return MMAlgos.brightness_contrast(c, brightness, contrast); +MMBrightnessContrast::~MMBrightnessContrast() { } - //brightness; +void MMBrightnessContrast::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMBrightnessContrast::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMBrightnessContrast::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_image", "get_image"); - float BrightnessContrast::get_brightness() { - return brightness; + ClassDB::bind_method(D_METHOD("get_input"), &MMBrightnessContrast::get_input); + ClassDB::bind_method(D_METHOD("set_input", "value"), &MMBrightnessContrast::set_input); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input", "get_input"); + + ClassDB::bind_method(D_METHOD("get_brightness"), &MMBrightnessContrast::get_brightness); + ClassDB::bind_method(D_METHOD("set_brightness", "value"), &MMBrightnessContrast::set_brightness); + ADD_PROPERTY(PropertyInfo(Variant::REAL, "brightness"), "set_brightness", "get_brightness"); + + ClassDB::bind_method(D_METHOD("get_contrast"), &MMBrightnessContrast::get_contrast); + ClassDB::bind_method(D_METHOD("set_contrast", "value"), &MMBrightnessContrast::set_contrast); + ADD_PROPERTY(PropertyInfo(Variant::REAL, "contrast"), "set_contrast", "get_contrast"); } - - - void BrightnessContrast::set_brightness(const float val) { - brightness = val; - set_dirty(true); -} - - //contrast; - - float BrightnessContrast::get_contrast() { - return contrast; -} - - - void BrightnessContrast::set_contrast(const float val) { - contrast = val; - set_dirty(true); -} - -} - - BrightnessContrast::BrightnessContrast() { - image; - input; - brightness = 0; - contrast = 1; - } - - BrightnessContrast::~BrightnessContrast() { - } - - - static void BrightnessContrast::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &BrightnessContrast::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &BrightnessContrast::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input"), &BrightnessContrast::get_input); - ClassDB::bind_method(D_METHOD("set_input", "value"), &BrightnessContrast::set_input); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - - - ClassDB::bind_method(D_METHOD("get_brightness"), &BrightnessContrast::get_brightness); - ClassDB::bind_method(D_METHOD("set_brightness", "value"), &BrightnessContrast::set_brightness); - ADD_PROPERTY(PropertyInfo(Variant::REAL, "brightness"), "set_brightness", "get_brightness"); - - - ClassDB::bind_method(D_METHOD("get_contrast"), &BrightnessContrast::get_contrast); - ClassDB::bind_method(D_METHOD("set_contrast", "value"), &BrightnessContrast::set_contrast); - ADD_PROPERTY(PropertyInfo(Variant::REAL, "contrast"), "set_contrast", "get_contrast"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &BrightnessContrast::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &BrightnessContrast::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &BrightnessContrast::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &BrightnessContrast::_get_value_for); - ClassDB::bind_method(D_METHOD("get_brightness"), &BrightnessContrast::get_brightness); - ClassDB::bind_method(D_METHOD("set_brightness", "val"), &BrightnessContrast::set_brightness); - ClassDB::bind_method(D_METHOD("get_contrast"), &BrightnessContrast::get_contrast); - ClassDB::bind_method(D_METHOD("set_contrast", "val"), &BrightnessContrast::set_contrast); - - } - - - diff --git a/modules/material_maker/nodes/filter/brightness_contrast.h b/modules/material_maker/nodes/filter/brightness_contrast.h index ada152479..c77708f4f 100644 --- a/modules/material_maker/nodes/filter/brightness_contrast.h +++ b/modules/material_maker/nodes/filter/brightness_contrast.h @@ -1,51 +1,40 @@ -#ifndef BRIGHTNESS_CONTRAST_H -#define BRIGHTNESS_CONTRAST_H +#ifndef MM_BRIGHTNESS_CONTRAST_H +#define MM_BRIGHTNESS_CONTRAST_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class BrightnessContrast : public MMNode { - GDCLASS(BrightnessContrast, MMNode); +class MMBrightnessContrast : public MMNode { + GDCLASS(MMBrightnessContrast, MMNode); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input(); + void set_input(const Ref &val); - Ref get_input(); - void set_input(const Ref &val); + float get_brightness() const; + void set_brightness(const float val); - float get_brightness() const; - void set_brightness(const float val); + float get_contrast() const; + void set_contrast(const float val); - float get_contrast() const; - void set_contrast(const float val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); - float get_brightness(); - void set_brightness(const float val); - float get_contrast(); - void set_contrast(const float val); + MMBrightnessContrast(); + ~MMBrightnessContrast(); - BrightnessContrast(); - ~BrightnessContrast(); +protected: + static void _bind_methods(); - protected: - static void _bind_methods(); - - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref input; - //export(float) - float brightness = 0; - //export(float) - float contrast = 1; - //brightness - //contrast + Ref image; + Ref input; + float brightness; + float contrast; }; - #endif diff --git a/modules/material_maker/nodes/filter/colorize.cpp b/modules/material_maker/nodes/filter/colorize.cpp index b2aa5a718..ebaa2dfa2 100644 --- a/modules/material_maker/nodes/filter/colorize.cpp +++ b/modules/material_maker/nodes/filter/colorize.cpp @@ -1,129 +1,93 @@ #include "colorize.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref Colorize::get_image() { - return image; +Ref MMColorize::get_image() { + return image; } -void Colorize::set_image(const Ref &val) { -image = val; +void MMColorize::set_image(const Ref &val) { + image = val; } - -Ref Colorize::get_input() { - return input; +Ref MMColorize::get_input() { + return input; } -void Colorize::set_input(const Ref &val) { -input = val; +void MMColorize::set_input(const Ref &val) { + input = val; } +void MMColorize::_init_properties() { + if (!input.is_valid()) { + input.instance(); + input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_FLOAT); + input->set_default_value(1); + } + input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input->set_slot_name(">>> Input1 "); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input; + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } - void Colorize::_init_properties() { + //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); + //image.force_override = true; - if (!input) { - input = MMNodeUniversalProperty.new(); - input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_FLOAT; - input.set_default_value(1); + register_input_property(input); + register_output_property(image); } - input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input.slot_name = ">>> Input1 "; - - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; +void MMColorize::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_label_universal(input); + mm_graph_node->add_slot_texture_universal(image); + mm_graph_node->add_slot_gradient(); } - //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - //image.force_override = true; - register_input_property(input); - register_output_property(image); +void MMColorize::_render(const Ref &material) { + Ref img = render_image(material); + image->set_value(img); } - - void Colorize::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_label_universal(input); - mm_graph_node.add_slot_texture_universal(image); - mm_graph_node.add_slot_gradient(); +Color MMColorize::_get_value_for(const Vector2 &uv, const int pseed) { + float f = input->get_value(uv); + return get_gradient_color(f); } +// return Color(0.5, 0.5, 0.5, 1); - void Colorize::_render(const Variant &material) { - Ref img = render_image(material); - image.set_value(img); +Color MMColorize::_get_gradient_color(const float x) { + if (interpolation_type == 0) { + return MMAlgos::gradient_type_1(x, points); + } else if (interpolation_type == 1) { + return MMAlgos::gradient_type_2(x, points); + } else if (interpolation_type == 2) { + return MMAlgos::gradient_type_3(x, points); + } else if (interpolation_type == 3) { + return MMAlgos::gradient_type_4(x, points); + } + + return Color(1, 1, 1, 1); } - - Color Colorize::_get_value_for(const Vector2 &uv, const int pseed) { - float f = input.get_value(uv); - return get_gradient_color(f); +MMColorize::MMColorize() { } - // return Color(0.5, 0.5, 0.5, 1); - - Color Colorize::get_gradient_color(const float x) { - - if (interpolation_type == 0) { - return MMAlgos.gradient_type_1(x, points); +MMColorize::~MMColorize() { } +void MMColorize::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMColorize::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMColorize::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_image", "get_image"); - else if (interpolation_type == 1) { - return MMAlgos.gradient_type_2(x, points); + ClassDB::bind_method(D_METHOD("get_input"), &MMColorize::get_input); + ClassDB::bind_method(D_METHOD("set_input", "value"), &MMColorize::set_input); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input", "get_input"); } - - - else if (interpolation_type == 2) { - return MMAlgos.gradient_type_3(x, points); -} - - - else if (interpolation_type == 3) { - return MMAlgos.gradient_type_4(x, points); -} - - return Color(1, 1, 1, 1); -} - -} - - Colorize::Colorize() { - image; - input; - } - - Colorize::~Colorize() { - } - - - static void Colorize::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &Colorize::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &Colorize::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input"), &Colorize::get_input); - ClassDB::bind_method(D_METHOD("set_input", "value"), &Colorize::set_input); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &Colorize::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &Colorize::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &Colorize::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &Colorize::_get_value_for); - ClassDB::bind_method(D_METHOD("get_gradient_color", "x"), &Colorize::get_gradient_color); - - } - - - diff --git a/modules/material_maker/nodes/filter/colorize.h b/modules/material_maker/nodes/filter/colorize.h index 6179852b0..30c9723b0 100644 --- a/modules/material_maker/nodes/filter/colorize.h +++ b/modules/material_maker/nodes/filter/colorize.h @@ -1,37 +1,33 @@ -#ifndef COLORIZE_H -#define COLORIZE_H +#ifndef MM_COLORIZE_H +#define MM_COLORIZE_H +#include "../bases/gradient_base.h" +#include "../mm_node_universal_property.h" -class Colorize : public GradientBase { - GDCLASS(Colorize, GradientBase); +class MMColorize : public GradientBase { + GDCLASS(MMColorize, GradientBase); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input(); + void set_input(const Ref &val); - Ref get_input(); - void set_input(const Ref &val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); + Color _get_gradient_color(const float x); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); - Color get_gradient_color(const float x); + MMColorize(); + ~MMColorize(); - Colorize(); - ~Colorize(); +protected: + static void _bind_methods(); - protected: - static void _bind_methods(); - - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref input; - // return Color(0.5, 0.5, 0.5, 1) + Ref image; + Ref input; }; - #endif diff --git a/modules/material_maker/nodes/filter/combine.cpp b/modules/material_maker/nodes/filter/combine.cpp index 7db1c5bb3..76fd8acd5 100644 --- a/modules/material_maker/nodes/filter/combine.cpp +++ b/modules/material_maker/nodes/filter/combine.cpp @@ -1,188 +1,148 @@ #include "combine.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref Combine::get_image() { - return image; +Ref MMCombine::get_image() { + return image; } -void Combine::set_image(const Ref &val) { -image = val; +void MMCombine::set_image(const Ref &val) { + image = val; } - -Ref Combine::get_input_r() { - return input_r; +Ref MMCombine::get_input_r() { + return input_r; } -void Combine::set_input_r(const Ref &val) { -input_r = val; +void MMCombine::set_input_r(const Ref &val) { + input_r = val; } - -Ref Combine::get_input_g() { - return input_g; +Ref MMCombine::get_input_g() { + return input_g; } -void Combine::set_input_g(const Ref &val) { -input_g = val; +void MMCombine::set_input_g(const Ref &val) { + input_g = val; } - -Ref Combine::get_input_b() { - return input_b; +Ref MMCombine::get_input_b() { + return input_b; } -void Combine::set_input_b(const Ref &val) { -input_b = val; +void MMCombine::set_input_b(const Ref &val) { + input_b = val; } - -Ref Combine::get_input_a() { - return input_a; +Ref MMCombine::get_input_a() { + return input_a; } -void Combine::set_input_a(const Ref &val) { -input_a = val; +void MMCombine::set_input_a(const Ref &val) { + input_a = val; } +void MMCombine::_init_properties() { + if (!input_r.is_valid()) { + input_r.instance(); + input_r->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_FLOAT); + input_r->set_default_value(0); + } + input_r->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input_r->set_slot_name(">>> R "); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input_r; - //export(Resource) ; - Ref input_g; - //export(Resource) ; - Ref input_b; - //export(Resource) ; - Ref input_a; + if (!input_g.is_valid()) { + input_g.instance(); + input_g->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_FLOAT); + input_g->set_default_value(0); + } - void Combine::_init_properties() { + input_g->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input_g->set_slot_name(">>> G "); - if (!input_r) { - input_r = MMNodeUniversalProperty.new(); - input_r.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_FLOAT; - input_r.set_default_value(0); + if (!input_b.is_valid()) { + input_b.instance(); + input_b->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_FLOAT); + input_b->set_default_value(0); + } + + input_b->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input_b->set_slot_name(">>> B "); + + if (!input_a.is_valid()) { + input_a.instance(); + input_a->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_FLOAT); + input_a->set_default_value(1); + } + + input_a->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input_a->set_slot_name(">>> A "); + + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } + + //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); + //image.force_override = true; + + register_input_property(input_r); + register_input_property(input_g); + register_input_property(input_b); + register_input_property(input_a); + register_output_property(image); } - input_r.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input_r.slot_name = ">>> R "; - - if (!input_g) { - input_g = MMNodeUniversalProperty.new(); - input_g.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_FLOAT; - input_g.set_default_value(0); +void MMCombine::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_label_universal(input_r); + mm_graph_node->add_slot_label_universal(input_g); + mm_graph_node->add_slot_label_universal(input_b); + mm_graph_node->add_slot_label_universal(input_a); + mm_graph_node->add_slot_texture_universal(image); } - input_g.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input_g.slot_name = ">>> G "; - - if (!input_b) { - input_b = MMNodeUniversalProperty.new(); - input_b.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_FLOAT; - input_b.set_default_value(0); +void MMCombine::_render(const Ref &material) { + Ref img = render_image(material); + image->set_value(img); } - input_b.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input_b.slot_name = ">>> B "; - - if (!input_a) { - input_a = MMNodeUniversalProperty.new(); - input_a.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_FLOAT; - input_a.set_default_value(1); +Color MMCombine::_get_value_for(const Vector2 &uv, const int pseed) { + float r = input_r->get_value(uv); + float g = input_g->get_value(uv); + float b = input_b->get_value(uv); + float a = input_a->get_value(uv); + return Color(r, g, b, a); } - input_a.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input_a.slot_name = ">>> A "; - - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; +MMCombine::MMCombine() { } - //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - //image.force_override = true; - register_input_property(input_r); - register_input_property(input_g); - register_input_property(input_b); - register_input_property(input_a); - register_output_property(image); +MMCombine::~MMCombine() { } +void MMCombine::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMCombine::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMCombine::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_image", "get_image"); - void Combine::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_label_universal(input_r); - mm_graph_node.add_slot_label_universal(input_g); - mm_graph_node.add_slot_label_universal(input_b); - mm_graph_node.add_slot_label_universal(input_a); - mm_graph_node.add_slot_texture_universal(image); + ClassDB::bind_method(D_METHOD("get_input_r"), &MMCombine::get_input_r); + ClassDB::bind_method(D_METHOD("set_input_r", "value"), &MMCombine::set_input_r); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input_r", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input_r", "get_input_r"); + + ClassDB::bind_method(D_METHOD("get_input_g"), &MMCombine::get_input_g); + ClassDB::bind_method(D_METHOD("set_input_g", "value"), &MMCombine::set_input_g); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input_g", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input_g", "get_input_g"); + + ClassDB::bind_method(D_METHOD("get_input_b"), &MMCombine::get_input_b); + ClassDB::bind_method(D_METHOD("set_input_b", "value"), &MMCombine::set_input_b); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input_b", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input_b", "get_input_b"); + + ClassDB::bind_method(D_METHOD("get_input_a"), &MMCombine::get_input_a); + ClassDB::bind_method(D_METHOD("set_input_a", "value"), &MMCombine::set_input_a); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input_a", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input_a", "get_input_a"); } - - - void Combine::_render(const Variant &material) { - Ref img = render_image(material); - image.set_value(img); -} - - - Color Combine::_get_value_for(const Vector2 &uv, const int pseed) { - float r = input_r.get_value(uv); - float g = input_g.get_value(uv); - float b = input_b.get_value(uv); - float a = input_a.get_value(uv); - return Color(r, g, b, a); -} - -} - - Combine::Combine() { - image; - input_r; - input_g; - input_b; - input_a; - } - - Combine::~Combine() { - } - - - static void Combine::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &Combine::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &Combine::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input_r"), &Combine::get_input_r); - ClassDB::bind_method(D_METHOD("set_input_r", "value"), &Combine::set_input_r); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input_r", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input_r", "get_input_r"); - - - ClassDB::bind_method(D_METHOD("get_input_g"), &Combine::get_input_g); - ClassDB::bind_method(D_METHOD("set_input_g", "value"), &Combine::set_input_g); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input_g", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input_g", "get_input_g"); - - - ClassDB::bind_method(D_METHOD("get_input_b"), &Combine::get_input_b); - ClassDB::bind_method(D_METHOD("set_input_b", "value"), &Combine::set_input_b); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input_b", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input_b", "get_input_b"); - - - ClassDB::bind_method(D_METHOD("get_input_a"), &Combine::get_input_a); - ClassDB::bind_method(D_METHOD("set_input_a", "value"), &Combine::set_input_a); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input_a", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input_a", "get_input_a"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &Combine::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &Combine::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &Combine::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &Combine::_get_value_for); - - } - - - diff --git a/modules/material_maker/nodes/filter/combine.h b/modules/material_maker/nodes/filter/combine.h index 9fd0e1b4c..dc1de3c58 100644 --- a/modules/material_maker/nodes/filter/combine.h +++ b/modules/material_maker/nodes/filter/combine.h @@ -1,50 +1,44 @@ -#ifndef COMBINE_H -#define COMBINE_H +#ifndef MM_COMBINE_H +#define MM_COMBINE_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class Combine : public MMNode { - GDCLASS(Combine, MMNode); +class MMCombine : public MMNode { + GDCLASS(MMCombine, MMNode); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input_r(); + void set_input_r(const Ref &val); - Ref get_input_r(); - void set_input_r(const Ref &val); + Ref get_input_g(); + void set_input_g(const Ref &val); - Ref get_input_g(); - void set_input_g(const Ref &val); + Ref get_input_b(); + void set_input_b(const Ref &val); - Ref get_input_b(); - void set_input_b(const Ref &val); + Ref get_input_a(); + void set_input_a(const Ref &val); - Ref get_input_a(); - void set_input_a(const Ref &val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); + MMCombine(); + ~MMCombine(); - Combine(); - ~Combine(); +protected: + static void _bind_methods(); - protected: - static void _bind_methods(); - - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref input_r; - //export(Resource) - Ref input_g; - //export(Resource) - Ref input_b; - //export(Resource) - Ref input_a; + Ref image; + Ref input_r; + Ref input_g; + Ref input_b; + Ref input_a; }; - #endif diff --git a/modules/material_maker/nodes/filter/decompose.cpp b/modules/material_maker/nodes/filter/decompose.cpp index 65e878fda..a38220ed4 100644 --- a/modules/material_maker/nodes/filter/decompose.cpp +++ b/modules/material_maker/nodes/filter/decompose.cpp @@ -1,211 +1,178 @@ #include "decompose.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref Decompose::get_input() { - return input; +Ref MMDecompose::get_input() { + return input; } -void Decompose::set_input(const Ref &val) { -input = val; +void MMDecompose::set_input(const Ref &val) { + input = val; } - -Ref Decompose::get_out_r() { - return out_r; +Ref MMDecompose::get_out_r() { + return out_r; } -void Decompose::set_out_r(const Ref &val) { -out_r = val; +void MMDecompose::set_out_r(const Ref &val) { + out_r = val; } - -Ref Decompose::get_out_g() { - return out_g; +Ref MMDecompose::get_out_g() { + return out_g; } -void Decompose::set_out_g(const Ref &val) { -out_g = val; +void MMDecompose::set_out_g(const Ref &val) { + out_g = val; } - -Ref Decompose::get_out_b() { - return out_b; +Ref MMDecompose::get_out_b() { + return out_b; } -void Decompose::set_out_b(const Ref &val) { -out_b = val; +void MMDecompose::set_out_b(const Ref &val) { + out_b = val; } - -Ref Decompose::get_out_a() { - return out_a; +Ref MMDecompose::get_out_a() { + return out_a; } -void Decompose::set_out_a(const Ref &val) { -out_a = val; +void MMDecompose::set_out_a(const Ref &val) { + out_a = val; } +void MMDecompose::_init_properties() { + if (!input.is_valid()) { + input.instance(); + input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR); + input->set_default_value(Color(0, 0, 0, 1)); + } + input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input->set_slot_name(">>> Input "); - //tool; - //export(Resource) ; - Ref input; - //export(Resource) ; - Ref out_r; - //export(Resource) ; - Ref out_g; - //export(Resource) ; - Ref out_b; - //export(Resource) ; - Ref out_a; + if (!out_r.is_valid()) { + out_r.instance(); + out_r->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } - void Decompose::_init_properties() { + out_r->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); - if (!input) { - input = MMNodeUniversalProperty.new(); - input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; - input.set_default_value(Color(0, 0, 0, 1)); + if (!out_g.is_valid()) { + out_g.instance(); + out_g->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } + + out_g->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); + + if (!out_b.is_valid()) { + out_b.instance(); + out_b->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } + + out_b->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); + + if (!out_a.is_valid()) { + out_a.instance(); + out_a->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } + + out_a->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); + + register_input_property(input); + register_output_property(out_r); + register_output_property(out_g); + register_output_property(out_b); + register_output_property(out_a); } - input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input.slot_name = ">>> Input "; - - if (!out_r) { - out_r = MMNodeUniversalProperty.new(); - out_r.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; +void MMDecompose::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_label_universal(input); + mm_graph_node->add_slot_texture_universal(out_r); + mm_graph_node->add_slot_texture_universal(out_g); + mm_graph_node->add_slot_texture_universal(out_b); + mm_graph_node->add_slot_texture_universal(out_a); } - out_r.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; +void MMDecompose::_render(const Ref &material) { + Ref img_r; + Ref img_g; + Ref img_b; + Ref img_a; - if (!out_g) { - out_g = MMNodeUniversalProperty.new(); - out_g.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; + img_r.instance(); + img_g.instance(); + img_b.instance(); + img_a.instance(); + + img_r->create(material->image_size.x, material->image_size.y, false, Image::FORMAT_RGBA8); + img_g->create(material->image_size.x, material->image_size.y, false, Image::FORMAT_RGBA8); + img_b->create(material->image_size.x, material->image_size.y, false, Image::FORMAT_RGBA8); + img_a->create(material->image_size.x, material->image_size.y, false, Image::FORMAT_RGBA8); + + img_r->lock(); + img_g->lock(); + img_b->lock(); + img_a->lock(); + + float w = material->image_size.x; + float h = material->image_size.y; + //float pseed = Math::randf() + Math::rand(); + + for (int x = 0; x < material->image_size.x; ++x) { //x in range(material.image_size.x) + for (int y = 0; y < material->image_size.y; ++y) { //y in range(material.image_size.y) + Vector2 uv = Vector2(x / w, y / h); + Color c = input->get_value(uv); + img_r->set_pixel(x, y, Color(c.r, c.r, c.r, 1)); + img_g->set_pixel(x, y, Color(c.g, c.g, c.g, 1)); + img_b->set_pixel(x, y, Color(c.b, c.b, c.b, 1)); + img_a->set_pixel(x, y, Color(c.a, c.a, c.a, c.a)); + } + } + + img_r->unlock(); + img_g->unlock(); + img_b->unlock(); + img_a->unlock(); + + out_r->set_value(img_r); + out_g->set_value(img_g); + out_b->set_value(img_b); + out_a->set_value(img_a); } - out_g.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - - if (!out_b) { - out_b = MMNodeUniversalProperty.new(); - out_b.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; +Color MMDecompose::_get_value_for(const Vector2 &uv, const int pseed) { + return Color(); } - out_b.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - - if (!out_a) { - out_a = MMNodeUniversalProperty.new(); - out_a.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; +MMDecompose::MMDecompose() { } - out_a.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - register_input_property(input); - register_output_property(out_r); - register_output_property(out_g); - register_output_property(out_b); - register_output_property(out_a); +MMDecompose::~MMDecompose() { } +void MMDecompose::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_input"), &MMDecompose::get_input); + ClassDB::bind_method(D_METHOD("set_input", "value"), &MMDecompose::set_input); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input", "get_input"); - void Decompose::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_label_universal(input); - mm_graph_node.add_slot_texture_universal(out_r); - mm_graph_node.add_slot_texture_universal(out_g); - mm_graph_node.add_slot_texture_universal(out_b); - mm_graph_node.add_slot_texture_universal(out_a); + ClassDB::bind_method(D_METHOD("get_out_r"), &MMDecompose::get_out_r); + ClassDB::bind_method(D_METHOD("set_out_r", "value"), &MMDecompose::set_out_r); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "out_r", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_out_r", "get_out_r"); + + ClassDB::bind_method(D_METHOD("get_out_g"), &MMDecompose::get_out_g); + ClassDB::bind_method(D_METHOD("set_out_g", "value"), &MMDecompose::set_out_g); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "out_g", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_out_g", "get_out_g"); + + ClassDB::bind_method(D_METHOD("get_out_b"), &MMDecompose::get_out_b); + ClassDB::bind_method(D_METHOD("set_out_b", "value"), &MMDecompose::set_out_b); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "out_b", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_out_b", "get_out_b"); + + ClassDB::bind_method(D_METHOD("get_out_a"), &MMDecompose::get_out_a); + ClassDB::bind_method(D_METHOD("set_out_a", "value"), &MMDecompose::set_out_a); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "out_a", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_out_a", "get_out_a"); } - - - void Decompose::_render(const Variant &material) { - Ref img_r = Image.new(); - Ref img_g = Image.new(); - Ref img_b = Image.new(); - Ref img_a = Image.new(); - img_r.create(material.image_size.x, material.image_size.y, false, Image.FORMAT_RGBA8); - img_g.create(material.image_size.x, material.image_size.y, false, Image.FORMAT_RGBA8); - img_b.create(material.image_size.x, material.image_size.y, false, Image.FORMAT_RGBA8); - img_a.create(material.image_size.x, material.image_size.y, false, Image.FORMAT_RGBA8); - img_r.lock(); - img_g.lock(); - img_b.lock(); - img_a.lock(); - float w = material.image_size.x; - float h = material.image_size.y; - float pseed = randf() + randi(); - - for (int x = 0; x < material.image_size.x; ++x) { //x in range(material.image_size.x) - - for (int y = 0; y < material.image_size.y; ++y) { //y in range(material.image_size.y) - Vector2 uv = Vector2(x / w, y / h); - Color c = input.get_value(uv); - img_r.set_pixel(x, y, Color(c.r, c.r, c.r, 1)); - img_g.set_pixel(x, y, Color(c.g, c.g, c.g, 1)); - img_b.set_pixel(x, y, Color(c.b, c.b, c.b, 1)); - img_a.set_pixel(x, y, Color(c.a, c.a, c.a, c.a)); -} - -} - - img_r.unlock(); - img_g.unlock(); - img_b.unlock(); - img_a.unlock(); - out_r.set_value(img_r); - out_g.set_value(img_g); - out_b.set_value(img_b); - out_a.set_value(img_a); -} - - - Color Decompose::_get_value_for(const Vector2 &uv, const int pseed) { - return Color(); -} - -} - - Decompose::Decompose() { - input; - out_r; - out_g; - out_b; - out_a; - } - - Decompose::~Decompose() { - } - - - static void Decompose::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_input"), &Decompose::get_input); - ClassDB::bind_method(D_METHOD("set_input", "value"), &Decompose::set_input); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - - - ClassDB::bind_method(D_METHOD("get_out_r"), &Decompose::get_out_r); - ClassDB::bind_method(D_METHOD("set_out_r", "value"), &Decompose::set_out_r); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "out_r", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_out_r", "get_out_r"); - - - ClassDB::bind_method(D_METHOD("get_out_g"), &Decompose::get_out_g); - ClassDB::bind_method(D_METHOD("set_out_g", "value"), &Decompose::set_out_g); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "out_g", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_out_g", "get_out_g"); - - - ClassDB::bind_method(D_METHOD("get_out_b"), &Decompose::get_out_b); - ClassDB::bind_method(D_METHOD("set_out_b", "value"), &Decompose::set_out_b); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "out_b", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_out_b", "get_out_b"); - - - ClassDB::bind_method(D_METHOD("get_out_a"), &Decompose::get_out_a); - ClassDB::bind_method(D_METHOD("set_out_a", "value"), &Decompose::set_out_a); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "out_a", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_out_a", "get_out_a"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &Decompose::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &Decompose::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &Decompose::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &Decompose::_get_value_for); - - } - - - diff --git a/modules/material_maker/nodes/filter/decompose.h b/modules/material_maker/nodes/filter/decompose.h index 46af67952..2c5372525 100644 --- a/modules/material_maker/nodes/filter/decompose.h +++ b/modules/material_maker/nodes/filter/decompose.h @@ -1,50 +1,44 @@ -#ifndef DECOMPOSE_H -#define DECOMPOSE_H +#ifndef MM_DECOMPOSE_H +#define MM_DECOMPOSE_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class Decompose : public MMNode { - GDCLASS(Decompose, MMNode); +class MMDecompose : public MMNode { + GDCLASS(MMDecompose, MMNode); - public: +public: + Ref get_input(); + void set_input(const Ref &val); - Ref get_input(); - void set_input(const Ref &val); + Ref get_out_r(); + void set_out_r(const Ref &val); - Ref get_out_r(); - void set_out_r(const Ref &val); + Ref get_out_g(); + void set_out_g(const Ref &val); - Ref get_out_g(); - void set_out_g(const Ref &val); + Ref get_out_b(); + void set_out_b(const Ref &val); - Ref get_out_b(); - void set_out_b(const Ref &val); + Ref get_out_a(); + void set_out_a(const Ref &val); - Ref get_out_a(); - void set_out_a(const Ref &val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); + MMDecompose(); + ~MMDecompose(); - Decompose(); - ~Decompose(); +protected: + static void _bind_methods(); - protected: - static void _bind_methods(); - - //tool - //export(Resource) - Ref input; - //export(Resource) - Ref out_r; - //export(Resource) - Ref out_g; - //export(Resource) - Ref out_b; - //export(Resource) - Ref out_a; + Ref input; + Ref out_r; + Ref out_g; + Ref out_b; + Ref out_a; }; - #endif diff --git a/modules/material_maker/nodes/filter/emboss.cpp b/modules/material_maker/nodes/filter/emboss.cpp index 1bf10a753..4e8427dc2 100644 --- a/modules/material_maker/nodes/filter/emboss.cpp +++ b/modules/material_maker/nodes/filter/emboss.cpp @@ -1,253 +1,177 @@ #include "emboss.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref Emboss::get_image() { - return image; +Ref MMEmboss::get_image() { + return image; } -void Emboss::set_image(const Ref &val) { -image = val; +void MMEmboss::set_image(const Ref &val) { + image = val; } - -Ref Emboss::get_input() { - return input; +Ref MMEmboss::get_input() { + return input; } -void Emboss::set_input(const Ref &val) { -input = val; +void MMEmboss::set_input(const Ref &val) { + input = val; } - -float Emboss::get_angle() const { - return angle; +float MMEmboss::get_angle() const { + return angle; } -void Emboss::set_angle(const float val) { -angle = val; +void MMEmboss::set_angle(const float val) { + angle = val; + set_dirty(true); } - -float Emboss::get_amount() const { - return amount; +float MMEmboss::get_amount() const { + return amount; } -void Emboss::set_amount(const float val) { -amount = val; +void MMEmboss::set_amount(const float val) { + amount = val; + set_dirty(true); } - -float Emboss::get_width() const { - return width; +float MMEmboss::get_width() const { + return width; } -void Emboss::set_width(const float val) { -width = val; +void MMEmboss::set_width(const float val) { + width = val; + set_dirty(true); } - -int Emboss::get_size() const { - return size; +int MMEmboss::get_size() const { + return size; } -void Emboss::set_size(const int val) { -size = val; +void MMEmboss::set_size(const int val) { + size = val; + set_dirty(true); } +void MMEmboss::_init_properties() { + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input; - //export(float) ; - float angle = 0; - //export(float) ; - float amount = 5; - //export(float) ; - float width = 1; - int size = 0; + if (!input.is_valid()) { + input.instance(); + input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_FLOAT); + input->set_default_value(1); + } - void Emboss::_init_properties() { + input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input->set_slot_name(">>> Input1 "); - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; + register_input_property(input); + register_output_property(image); } - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - - if (!input) { - input = MMNodeUniversalProperty.new(); - input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_FLOAT; - input.set_default_value(1); +void MMEmboss::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_texture_universal(image); + mm_graph_node->add_slot_label_universal(input); + mm_graph_node->add_slot_float("get_angle", "set_angle", "Angle", 0.1); + mm_graph_node->add_slot_float("get_amount", "set_amount", "Amount", 0.1); + mm_graph_node->add_slot_float("get_width", "set_width", "Width", 1); } - input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input.slot_name = ">>> Input1 "; - register_input_property(input); - register_output_property(image); +void MMEmboss::_render(const Ref &material) { + size = MAX(material->image_size.x, material->image_size.y); + Ref img = render_image(material); + image->set_value(img); } - - void Emboss::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_texture_universal(image); - mm_graph_node.add_slot_label_universal(input); - mm_graph_node.add_slot_float("get_angle", "set_angle", "Angle", 0.1); - mm_graph_node.add_slot_float("get_amount", "set_amount", "Amount", 0.1); - mm_graph_node.add_slot_float("get_width", "set_width", "Width", 1); +Color MMEmboss::_get_value_for(const Vector2 &uv, const int pseed) { + float f = 0; + f = emboss(uv, size, angle, amount, width); + return Color(f, f, f, 1); } +//float $(name)_fct(vec2 uv) {; +// float pixels = max(1.0, $width); +// float e = 1.0/$size; +// float rv = 0.0; +//; +// for (float dx = -pixels; dx <= pixels; dx += 1.0) {; +// for (float dy = -pixels; dy <= pixels; dy += 1.0) {; +// if (abs(dx) > 0.5 || abs(dy) > 0.5) {; +// rv += $in(uv+e*vec2(dx, dy))*cos(atan(dy, dx)-$angle*3.14159265359/180.0)/length(vec2(dx, dy)); +// }; +// }; +// }; +//; +// return $amount*rv/pixels+0.5; +//}; - void Emboss::_render(const Variant &material) { - size = max(material.image_size.x, material.image_size.y); - Ref img = render_image(material); - image.set_value(img); +float MMEmboss::emboss(const Vector2 &uv, const float psize, const float pangle, const float pamount, const float pwidth) { + float pixels = MAX(1.0, pwidth); + float e = 1.0 / psize; + float rv = 0.0; + float dx = -pixels; + float dy = -pixels; + //for (float dx = -pixels; dx <= pixels; dx += 1.0) {; + + while (dx <= pixels) { + //for (float dy = -pixels; dy <= pixels; dy += 1.0) {; + + while (dy <= pixels) { + if ((abs(dx) > 0.5 || abs(dy) > 0.5)) { + rv += float(input->get_value(uv + e * Vector2(dx, dy))) * Math::cos(Math::atan2(dy, dx) - pangle * 3.14159265359 / 180.0) / Vector2(dx, dy).length(); + } + + dx += 1; + dy += 1; + } + } + + return pamount * rv / pixels + 0.5; } - - Color Emboss::_get_value_for(const Vector2 &uv, const int pseed) { - float f = 0; - f = emboss(uv, size, angle, amount, width); - return Color(f, f, f, 1); +MMEmboss::MMEmboss() { + angle = 0; + amount = 5; + width = 1; + size = 0; } - - float Emboss::get_angle() { - return angle; +MMEmboss::~MMEmboss() { } +void MMEmboss::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMEmboss::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMEmboss::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_image", "get_image"); - void Emboss::set_angle(const float val) { - angle = val; - set_dirty(true); + ClassDB::bind_method(D_METHOD("get_input"), &MMEmboss::get_input); + ClassDB::bind_method(D_METHOD("set_input", "value"), &MMEmboss::set_input); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input", "get_input"); + + ClassDB::bind_method(D_METHOD("get_angle"), &MMEmboss::get_angle); + ClassDB::bind_method(D_METHOD("set_angle", "value"), &MMEmboss::set_angle); + ADD_PROPERTY(PropertyInfo(Variant::REAL, "angle"), "set_angle", "get_angle"); + + ClassDB::bind_method(D_METHOD("get_amount"), &MMEmboss::get_amount); + ClassDB::bind_method(D_METHOD("set_amount", "value"), &MMEmboss::set_amount); + ADD_PROPERTY(PropertyInfo(Variant::REAL, "amount"), "set_amount", "get_amount"); + + ClassDB::bind_method(D_METHOD("get_width"), &MMEmboss::get_width); + ClassDB::bind_method(D_METHOD("set_width", "value"), &MMEmboss::set_width); + ADD_PROPERTY(PropertyInfo(Variant::REAL, "width"), "set_width", "get_width"); + + ClassDB::bind_method(D_METHOD("get_size"), &MMEmboss::get_size); + ClassDB::bind_method(D_METHOD("set_size", "value"), &MMEmboss::set_size); + ADD_PROPERTY(PropertyInfo(Variant::INT, "size"), "set_size", "get_size"); + + ClassDB::bind_method(D_METHOD("emboss", "uv", "psize", "pangle", "pamount", "pwidth"), &MMEmboss::emboss); } - - - float Emboss::get_amount() { - return amount; -} - - - void Emboss::set_amount(const float val) { - amount = val; - set_dirty(true); -} - - - float Emboss::get_width() { - return width; -} - - - void Emboss::set_width(const float val) { - width = val; - set_dirty(true); -} - - //float $(name)_fct(vec2 uv) {; - // float pixels = max(1.0, $width); - // float e = 1.0/$size; - // float rv = 0.0; - //; - // for (float dx = -pixels; dx <= pixels; dx += 1.0) {; - // for (float dy = -pixels; dy <= pixels; dy += 1.0) {; - // if (abs(dx) > 0.5 || abs(dy) > 0.5) {; - // rv += $in(uv+e*vec2(dx, dy))*cos(atan(dy, dx)-$angle*3.14159265359/180.0)/length(vec2(dx, dy)); - // }; - // }; - // }; - //; - // return $amount*rv/pixels+0.5; - //}; - - float Emboss::emboss(const Vector2 &uv, const float psize, const float pangle, const float pamount, const float pwidth) { - float pixels = max(1.0, pwidth); - float e = 1.0 / psize; - float rv = 0.0; - float dx = -pixels; - float dy = -pixels; - //for (float dx = -pixels; dx <= pixels; dx += 1.0) {; - - while (dx <= pixels) { - //for (float dy = -pixels; dy <= pixels; dy += 1.0) {; - - while (dy <= pixels) { - - if ((abs(dx) > 0.5 || abs(dy) > 0.5)) { - rv += input.get_value(uv + e * Vector2(dx, dy)) * cos(atan2(dy, dx) - pangle * 3.14159265359 / 180.0) / Vector2(dx, dy).length(); -} - - dx += 1; - dy += 1; -} - -} - - return pamount * rv / pixels + 0.5; -} - -} - - Emboss::Emboss() { - image; - input; - angle = 0; - amount = 5; - width = 1; - size = 0; - } - - Emboss::~Emboss() { - } - - - static void Emboss::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &Emboss::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &Emboss::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input"), &Emboss::get_input); - ClassDB::bind_method(D_METHOD("set_input", "value"), &Emboss::set_input); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - - - ClassDB::bind_method(D_METHOD("get_angle"), &Emboss::get_angle); - ClassDB::bind_method(D_METHOD("set_angle", "value"), &Emboss::set_angle); - ADD_PROPERTY(PropertyInfo(Variant::REAL, "angle"), "set_angle", "get_angle"); - - - ClassDB::bind_method(D_METHOD("get_amount"), &Emboss::get_amount); - ClassDB::bind_method(D_METHOD("set_amount", "value"), &Emboss::set_amount); - ADD_PROPERTY(PropertyInfo(Variant::REAL, "amount"), "set_amount", "get_amount"); - - - ClassDB::bind_method(D_METHOD("get_width"), &Emboss::get_width); - ClassDB::bind_method(D_METHOD("set_width", "value"), &Emboss::set_width); - ADD_PROPERTY(PropertyInfo(Variant::REAL, "width"), "set_width", "get_width"); - - - ClassDB::bind_method(D_METHOD("get_size"), &Emboss::get_size); - ClassDB::bind_method(D_METHOD("set_size", "value"), &Emboss::set_size); - ADD_PROPERTY(PropertyInfo(Variant::INT, "size"), "set_size", "get_size"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &Emboss::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &Emboss::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &Emboss::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &Emboss::_get_value_for); - ClassDB::bind_method(D_METHOD("get_angle"), &Emboss::get_angle); - ClassDB::bind_method(D_METHOD("set_angle", "val"), &Emboss::set_angle); - ClassDB::bind_method(D_METHOD("get_amount"), &Emboss::get_amount); - ClassDB::bind_method(D_METHOD("set_amount", "val"), &Emboss::set_amount); - ClassDB::bind_method(D_METHOD("get_width"), &Emboss::get_width); - ClassDB::bind_method(D_METHOD("set_width", "val"), &Emboss::set_width); - ClassDB::bind_method(D_METHOD("emboss", "uv", "psize", "pangle", "pamount", "pwidth"), &Emboss::emboss); - - } - - - diff --git a/modules/material_maker/nodes/filter/emboss.h b/modules/material_maker/nodes/filter/emboss.h index 6e67e305d..c75664dce 100644 --- a/modules/material_maker/nodes/filter/emboss.h +++ b/modules/material_maker/nodes/filter/emboss.h @@ -1,76 +1,50 @@ -#ifndef EMBOSS_H -#define EMBOSS_H +#ifndef MM_EMBOSS_H +#define MM_EMBOSS_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class Emboss : public MMNode { - GDCLASS(Emboss, MMNode); +class MMEmboss : public MMNode { + GDCLASS(MMEmboss, MMNode); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input(); + void set_input(const Ref &val); - Ref get_input(); - void set_input(const Ref &val); + float get_angle() const; + void set_angle(const float val); - float get_angle() const; - void set_angle(const float val); + float get_amount() const; + void set_amount(const float val); - float get_amount() const; - void set_amount(const float val); + float get_width() const; + void set_width(const float val); - float get_width() const; - void set_width(const float val); + int get_size() const; + void set_size(const int val); - int get_size() const; - void set_size(const int val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); - float get_angle(); - void set_angle(const float val); - float get_amount(); - void set_amount(const float val); - float get_width(); - void set_width(const float val); - float emboss(const Vector2 &uv, const float psize, const float pangle, const float pamount, const float pwidth); + float emboss(const Vector2 &uv, const float psize, const float pangle, const float pamount, const float pwidth); - Emboss(); - ~Emboss(); + MMEmboss(); + ~MMEmboss(); - protected: - static void _bind_methods(); +protected: + static void _bind_methods(); - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref input; - //export(float) - float angle = 0; - //export(float) - float amount = 5; - //export(float) - float width = 1; - int size = 0; - //float $(name)_fct(vec2 uv) { - // float pixels = max(1.0, $width); - // float e = 1.0/$size; - // float rv = 0.0; - // - // for (float dx = -pixels; dx <= pixels; dx += 1.0) { - // for (float dy = -pixels; dy <= pixels; dy += 1.0) { - // if (abs(dx) > 0.5 || abs(dy) > 0.5) { - // rv += $in(uv+e*vec2(dx, dy))*cos(atan(dy, dx)-$angle*3.14159265359/180.0)/length(vec2(dx, dy)); - // } - // } - // } - // - // return $amount*rv/pixels+0.5; - //} + Ref image; + Ref input; + float angle; + float amount; + float width; + int size; }; - #endif diff --git a/modules/material_maker/nodes/filter/fill_channel.cpp b/modules/material_maker/nodes/filter/fill_channel.cpp index 64c4c7cce..574d88c45 100644 --- a/modules/material_maker/nodes/filter/fill_channel.cpp +++ b/modules/material_maker/nodes/filter/fill_channel.cpp @@ -1,179 +1,137 @@ #include "fill_channel.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref FillChannel::get_image() { - return image; +Ref MMFillChannel::get_image() { + return image; } -void FillChannel::set_image(const Ref &val) { -image = val; +void MMFillChannel::set_image(const Ref &val) { + image = val; } - -Ref FillChannel::get_input() { - return input; +Ref MMFillChannel::get_input() { + return input; } -void FillChannel::set_input(const Ref &val) { -input = val; +void MMFillChannel::set_input(const Ref &val) { + input = val; } - -Ref FillChannel::get_value() { - return value; +Ref MMFillChannel::get_value() { + return value; } -void FillChannel::set_value(const Ref &val) { -value = val; +void MMFillChannel::set_value(const Ref &val) { + value = val; } - -int FillChannel::get_channel() const { - return channel; +int MMFillChannel::get_channel() const { + return channel; } -void FillChannel::set_channel(const int val) { -channel = val; +void MMFillChannel::set_channel(const int val) { + channel = val; + set_dirty(true); } +void MMFillChannel::_init_properties() { + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input; - //export(Resource) ; - Ref value; - //export(int, "R,G,B,A") ; - int channel = 3; + if (!input.is_valid()) { + input.instance(); + input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR); + input->set_default_value(Color()); + } - void FillChannel::_init_properties() { + input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input->set_slot_name(">>> Input1 "); - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; + if (!value.is_valid()) { + value.instance(); + value->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_FLOAT); + value->set_default_value(1); + } + + value->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + value->set_value_step(0.01); + value->set_value_range(Vector2(0, 1)); + + register_input_property(input); + register_output_property(image); + register_input_property(value); } - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; +void MMFillChannel::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_label_universal(input); + mm_graph_node->add_slot_texture_universal(image); + mm_graph_node->add_slot_float_universal(value); - if (!input) { - input = MMNodeUniversalProperty.new(); - input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; - input.set_default_value(Color()); + Array arr; + arr.push_back("R"); + arr.push_back("G"); + arr.push_back("B"); + arr.push_back("A"); + + mm_graph_node->add_slot_enum("get_channel", "set_channel", "Channel", arr); } - input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input.slot_name = ">>> Input1 "; - - if (!value) { - value = MMNodeUniversalProperty.new(); - value.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_FLOAT; - value.set_default_value(1); +void MMFillChannel::_render(const Ref &material) { + Ref img = render_image(material); + image->set_value(img); } - value.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - value.value_step = 0.01; - value.value_range = Vector2(0, 1); - register_input_property(input); - register_output_property(image); - register_input_property(value); +Color MMFillChannel::_get_value_for(const Vector2 &uv, const int pseed) { + Color col = input->get_value(uv); + + if (channel == 0) { + col.r = value->get_value(uv); + } + + if (channel == 1) { + col.g = value->get_value(uv); + } + + if (channel == 2) { + col.b = value->get_value(uv); + } + + if (channel == 3) { + col.a = value->get_value(uv); + } + + return col; } - - void FillChannel::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_label_universal(input); - mm_graph_node.add_slot_texture_universal(image); - mm_graph_node.add_slot_float_universal(value); - mm_graph_node.add_slot_enum("get_channel", "set_channel", "Channel", [ "R", "G", "B", "A" ]); +MMFillChannel::MMFillChannel() { + channel = 3; } - - void FillChannel::_render(const Variant &material) { - Ref img = render_image(material); - image.set_value(img); +MMFillChannel::~MMFillChannel() { } +void MMFillChannel::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMFillChannel::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMFillChannel::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - Color FillChannel::_get_value_for(const Vector2 &uv, const int pseed) { - Color col = input.get_value(uv); + ClassDB::bind_method(D_METHOD("get_input"), &MMFillChannel::get_input); + ClassDB::bind_method(D_METHOD("set_input", "value"), &MMFillChannel::set_input); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - if (channel == 0) { - col.r = value.get_value(uv); + ClassDB::bind_method(D_METHOD("get_value"), &MMFillChannel::get_value); + ClassDB::bind_method(D_METHOD("set_value", "value"), &MMFillChannel::set_value); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "value", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_value", "get_value"); + + ClassDB::bind_method(D_METHOD("get_channel"), &MMFillChannel::get_channel); + ClassDB::bind_method(D_METHOD("set_channel", "value"), &MMFillChannel::set_channel); + ADD_PROPERTY(PropertyInfo(Variant::INT, "channel"), "set_channel", "get_channel"); } - - - if (channel == 1) { - col.g = value.get_value(uv); -} - - - if (channel == 2) { - col.b = value.get_value(uv); -} - - - if (channel == 3) { - col.a = value.get_value(uv); -} - - return col; -} - - - int FillChannel::get_channel() { - return channel; -} - - - void FillChannel::set_channel(const int val) { - channel = val; - set_dirty(true); -} - -} - - FillChannel::FillChannel() { - image; - input; - value; - channel = 3; - } - - FillChannel::~FillChannel() { - } - - - static void FillChannel::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &FillChannel::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &FillChannel::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input"), &FillChannel::get_input); - ClassDB::bind_method(D_METHOD("set_input", "value"), &FillChannel::set_input); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - - - ClassDB::bind_method(D_METHOD("get_value"), &FillChannel::get_value); - ClassDB::bind_method(D_METHOD("set_value", "value"), &FillChannel::set_value); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "value", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_value", "get_value"); - - - ClassDB::bind_method(D_METHOD("get_channel"), &FillChannel::get_channel); - ClassDB::bind_method(D_METHOD("set_channel", "value"), &FillChannel::set_channel); - ADD_PROPERTY(PropertyInfo(Variant::INT, "channel"), "set_channel", "get_channel"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &FillChannel::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &FillChannel::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &FillChannel::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &FillChannel::_get_value_for); - ClassDB::bind_method(D_METHOD("get_channel"), &FillChannel::get_channel); - ClassDB::bind_method(D_METHOD("set_channel", "val"), &FillChannel::set_channel); - - } - - - diff --git a/modules/material_maker/nodes/filter/fill_channel.h b/modules/material_maker/nodes/filter/fill_channel.h index a8364e418..7f2a1b47d 100644 --- a/modules/material_maker/nodes/filter/fill_channel.h +++ b/modules/material_maker/nodes/filter/fill_channel.h @@ -1,47 +1,41 @@ -#ifndef FILL_CHANNEL_H -#define FILL_CHANNEL_H +#ifndef MM_FILL_CHANNEL_H +#define MM_FILL_CHANNEL_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class FillChannel : public MMNode { - GDCLASS(FillChannel, MMNode); +class MMFillChannel : public MMNode { + GDCLASS(MMFillChannel, MMNode); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input(); + void set_input(const Ref &val); - Ref get_input(); - void set_input(const Ref &val); + Ref get_value(); + void set_value(const Ref &val); - Ref get_value(); - void set_value(const Ref &val); + int get_channel() const; + void set_channel(const int val); - int get_channel() const; - void set_channel(const int val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); - int get_channel(); - void set_channel(const int val); + MMFillChannel(); + ~MMFillChannel(); - FillChannel(); - ~FillChannel(); +protected: + static void _bind_methods(); - protected: - static void _bind_methods(); - - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref input; - //export(Resource) - Ref value; - //export(int, "R,G,B,A") - int channel = 3; + Ref image; + Ref input; + Ref value; + //export(int, "R,G,B,A") + int channel; }; - #endif diff --git a/modules/material_maker/nodes/filter/fill_to_color.cpp b/modules/material_maker/nodes/filter/fill_to_color.cpp index aaec02979..8849eb8f0 100644 --- a/modules/material_maker/nodes/filter/fill_to_color.cpp +++ b/modules/material_maker/nodes/filter/fill_to_color.cpp @@ -1,165 +1,118 @@ #include "fill_to_color.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref FillToColor::get_image() { - return image; +Ref MMFillToColor::get_image() { + return image; } -void FillToColor::set_image(const Ref &val) { -image = val; +void MMFillToColor::set_image(const Ref &val) { + image = val; } - -Ref FillToColor::get_input() { - return input; +Ref MMFillToColor::get_input() { + return input; } -void FillToColor::set_input(const Ref &val) { -input = val; +void MMFillToColor::set_input(const Ref &val) { + input = val; } - -Ref FillToColor::get_color_map() { - return color_map; +Ref MMFillToColor::get_color_map() { + return color_map; } -void FillToColor::set_color_map(const Ref &val) { -color_map = val; +void MMFillToColor::set_color_map(const Ref &val) { + color_map = val; } - -Color FillToColor::get_edge_color() { - return edge_color; +Color MMFillToColor::get_edge_color() { + return edge_color; } -void FillToColor::set_edge_color(const Color &val) { -edge_color = val; +void MMFillToColor::set_edge_color(const Color &val) { + edge_color = val; + set_dirty(true); } +void MMFillToColor::_init_properties() { + if (!input.is_valid()) { + input.instance(); + input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR); + input->set_default_value(Color(0, 0, 0, 1)); + } + input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input->set_slot_name(">>> Input "); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input; - //export(Resource) ; - Ref color_map; - //export(Color) ; - Color edge_color = Color(1, 1, 1, 1); + if (!color_map.is_valid()) { + color_map.instance(); + color_map->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR); + color_map->set_default_value(Color(1, 1, 1, 1)); + } - void FillToColor::_init_properties() { + color_map->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + color_map->set_slot_name(">>> Color Map "); - if (!input) { - input = MMNodeUniversalProperty.new(); - input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; - input.set_default_value(Color(0, 0, 0, 1)); + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } + + //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); + //image.force_override = true; + + register_input_property(input); + register_input_property(color_map); + register_output_property(image); } - input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input.slot_name = ">>> Input "; - - if (!color_map) { - color_map = MMNodeUniversalProperty.new(); - color_map.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; - color_map.set_default_value(Color(1, 1, 1, 1)); +void MMFillToColor::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_label_universal(input); + mm_graph_node->add_slot_label_universal(color_map); + mm_graph_node->add_slot_texture_universal(image); + mm_graph_node->add_slot_color("get_edge_color", "set_edge_color"); } - color_map.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - color_map.slot_name = ">>> Color Map "; - - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; +void MMFillToColor::_render(const Ref &material) { + Ref img = render_image(material); + image->set_value(img); } - //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - //image.force_override = true; - register_input_property(input); - register_input_property(color_map); - register_output_property(image); +Color MMFillToColor::_get_value_for(const Vector2 &uv, const int pseed) { + //vec4 $(name_uv)_bb = $in($uv); + Color c = input->get_value(uv); + //mix($edgecolor, $map(fract($(name_uv)_bb.xy+0.5*$(name_uv)_bb.zw)), step(0.0000001, dot($(name_uv)_bb.zw, vec2(1.0)))); + Color rc = color_map->get_value(MMAlgos::fractv2(Vector2(c.r, c.g) + 0.5 * Vector2(c.b, c.a))); + float s = MMAlgos::step(0.0000001, Vector2(c.b, c.a).dot(Vector2(1, 1))); + return edge_color.linear_interpolate(rc, s); } - - void FillToColor::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_label_universal(input); - mm_graph_node.add_slot_label_universal(color_map); - mm_graph_node.add_slot_texture_universal(image); - mm_graph_node.add_slot_color("get_edge_color", "set_edge_color"); +MMFillToColor::MMFillToColor() { + edge_color = Color(1, 1, 1, 1); } - - void FillToColor::_render(const Variant &material) { - Ref img = render_image(material); - image.set_value(img); +MMFillToColor::~MMFillToColor() { } +void MMFillToColor::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMFillToColor::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMFillToColor::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_image", "get_image"); - Color FillToColor::_get_value_for(const Vector2 &uv, const int pseed) { - //vec4 $(name_uv)_bb = $in($uv); - Color c = input.get_value(uv); - //mix($edgecolor, $map(fract($(name_uv)_bb.xy+0.5*$(name_uv)_bb.zw)), step(0.0000001, dot($(name_uv)_bb.zw, vec2(1.0)))); - Color rc = color_map.get_value(MMAlgos.fractv2(Vector2(c.r, c.g) + 0.5 * Vector2(c.b, c.a))); - float s = MMAlgos.step(0.0000001, Vector2(c.b, c.a).dot(Vector2(1, 1))); - return lerp(edge_color, rc, s); + ClassDB::bind_method(D_METHOD("get_input"), &MMFillToColor::get_input); + ClassDB::bind_method(D_METHOD("set_input", "value"), &MMFillToColor::set_input); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input", "get_input"); + + ClassDB::bind_method(D_METHOD("get_color_map"), &MMFillToColor::get_color_map); + ClassDB::bind_method(D_METHOD("set_color_map", "value"), &MMFillToColor::set_color_map); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "color_map", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_color_map", "get_color_map"); + + ClassDB::bind_method(D_METHOD("get_edge_color"), &MMFillToColor::get_edge_color); + ClassDB::bind_method(D_METHOD("set_edge_color", "value"), &MMFillToColor::set_edge_color); + ADD_PROPERTY(PropertyInfo(Variant::COLOR, "edge_color"), "set_edge_color", "get_edge_color"); } - - //edge_color; - - Color FillToColor::get_edge_color() { - return edge_color; -} - - - void FillToColor::set_edge_color(const Color &val) { - edge_color = val; - set_dirty(true); -} - -} - - FillToColor::FillToColor() { - image; - input; - color_map; - edge_color = Color(1, 1, 1, 1); - } - - FillToColor::~FillToColor() { - } - - - static void FillToColor::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &FillToColor::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &FillToColor::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input"), &FillToColor::get_input); - ClassDB::bind_method(D_METHOD("set_input", "value"), &FillToColor::set_input); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - - - ClassDB::bind_method(D_METHOD("get_color_map"), &FillToColor::get_color_map); - ClassDB::bind_method(D_METHOD("set_color_map", "value"), &FillToColor::set_color_map); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "color_map", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_color_map", "get_color_map"); - - - ClassDB::bind_method(D_METHOD("get_edge_color"), &FillToColor::get_edge_color); - ClassDB::bind_method(D_METHOD("set_edge_color", "value"), &FillToColor::set_edge_color); - ADD_PROPERTY(PropertyInfo(Variant::COLOR, "edge_color"), "set_edge_color", "get_edge_color"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &FillToColor::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &FillToColor::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &FillToColor::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &FillToColor::_get_value_for); - ClassDB::bind_method(D_METHOD("get_edge_color"), &FillToColor::get_edge_color); - ClassDB::bind_method(D_METHOD("set_edge_color", "val"), &FillToColor::set_edge_color); - - } - - - diff --git a/modules/material_maker/nodes/filter/fill_to_color.h b/modules/material_maker/nodes/filter/fill_to_color.h index 2bb1ed90b..53dae9a41 100644 --- a/modules/material_maker/nodes/filter/fill_to_color.h +++ b/modules/material_maker/nodes/filter/fill_to_color.h @@ -1,48 +1,40 @@ -#ifndef FILL_TO_COLOR_H -#define FILL_TO_COLOR_H +#ifndef MM_FILL_TO_COLOR_H +#define MM_FILL_TO_COLOR_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class FillToColor : public MMNode { - GDCLASS(FillToColor, MMNode); +class MMFillToColor : public MMNode { + GDCLASS(MMFillToColor, MMNode); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input(); + void set_input(const Ref &val); - Ref get_input(); - void set_input(const Ref &val); + Ref get_color_map(); + void set_color_map(const Ref &val); - Ref get_color_map(); - void set_color_map(const Ref &val); + Color get_edge_color(); + void set_edge_color(const Color &val); - Color get_edge_color(); - void set_edge_color(const Color &val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); - Color get_edge_color(); - void set_edge_color(const Color &val); + MMFillToColor(); + ~MMFillToColor(); - FillToColor(); - ~FillToColor(); +protected: + static void _bind_methods(); - protected: - static void _bind_methods(); - - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref input; - //export(Resource) - Ref color_map; - //export(Color) - Color edge_color = Color(1, 1, 1, 1); - //edge_color + Ref image; + Ref input; + Ref color_map; + Color edge_color; }; - #endif diff --git a/modules/material_maker/nodes/filter/fill_to_position.cpp b/modules/material_maker/nodes/filter/fill_to_position.cpp index aacafee92..95e9126ee 100644 --- a/modules/material_maker/nodes/filter/fill_to_position.cpp +++ b/modules/material_maker/nodes/filter/fill_to_position.cpp @@ -1,154 +1,112 @@ #include "fill_to_position.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref FillToPosition::get_image() { - return image; +Ref MMFillToPosition::get_image() { + return image; } -void FillToPosition::set_image(const Ref &val) { -image = val; +void MMFillToPosition::set_image(const Ref &val) { + image = val; } - -Ref FillToPosition::get_input() { - return input; +Ref MMFillToPosition::get_input() { + return input; } -void FillToPosition::set_input(const Ref &val) { -input = val; +void MMFillToPosition::set_input(const Ref &val) { + input = val; } - -int FillToPosition::get_axis() const { - return axis; +int MMFillToPosition::get_axis() const { + return axis; } -void FillToPosition::set_axis(const int val) { -axis = val; +void MMFillToPosition::set_axis(const int val) { + axis = val; + set_dirty(true); } +void MMFillToPosition::_init_properties() { + if (!input.is_valid()) { + input.instance(); + input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR); + input->set_default_value(Color(0, 0, 0, 1)); + } + input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input->set_slot_name(">>> Input "); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input; - //export(int, "X,Y,Radial") ; - int axis = 2; + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } - void FillToPosition::_init_properties() { + //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); + //image.force_override = true; - if (!input) { - input = MMNodeUniversalProperty.new(); - input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; - input.set_default_value(Color(0, 0, 0, 1)); + register_input_property(input); + register_output_property(image); } - input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input.slot_name = ">>> Input "; +void MMFillToPosition::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_label_universal(input); + mm_graph_node->add_slot_texture_universal(image); - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; + Array arr; + arr.push_back("X"); + arr.push_back("Y"); + arr.push_back("Radial"); + + mm_graph_node->add_slot_enum("get_axis", "set_axis", "Axis", arr); } - //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - //image.force_override = true; - register_input_property(input); - register_output_property(image); +void MMFillToPosition::_render(const Ref &material) { + Ref img = render_image(material); + image->set_value(img); } +Color MMFillToPosition::_get_value_for(const Vector2 &uv, const int pseed) { + Color c = input->get_value(uv); + //vec2 $(name_uv)_c = fract($in($uv).xy+0.5*$in($uv).zw); + Vector2 cnv = MMAlgos::fractv2(Vector2(c.r, c.g) + 0.5 * Vector2(c.b, c.a)); + //X, $(name_uv)_c.x; + //Y, $(name_uv)_c.y; + //Radial, length($(name_uv)_c-vec2(0.5)); - void FillToPosition::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_label_universal(input); - mm_graph_node.add_slot_texture_universal(image); - mm_graph_node.add_slot_enum("get_axis", "set_axis", "Axis", [ "X", "Y", "Radial" ]); + if (axis == 0) { + return Color(cnv.x, cnv.x, cnv.x, 1); + } else if (axis == 1) { + return Color(cnv.y, cnv.y, cnv.y, 1); + } else if (axis == 2) { + float f = (cnv - Vector2(0.5, 0.5)).length(); + return Color(f, f, f, 1); + } + + return Color(0, 0, 0, 1); } - - void FillToPosition::_render(const Variant &material) { - Ref img = render_image(material); - image.set_value(img); +MMFillToPosition::MMFillToPosition() { + axis = 2; } - - Color FillToPosition::_get_value_for(const Vector2 &uv, const int pseed) { - Color c = input.get_value(uv); - //vec2 $(name_uv)_c = fract($in($uv).xy+0.5*$in($uv).zw); - Vector2 cnv = MMAlgos.fractv2(Vector2(c.r, c.g) + 0.5 * Vector2(c.b, c.a)); - //X, $(name_uv)_c.x; - //Y, $(name_uv)_c.y; - //Radial, length($(name_uv)_c-vec2(0.5)); - - if (axis == 0) { - return Color(cnv.x, cnv.x, cnv.x, 1); +MMFillToPosition::~MMFillToPosition() { } +void MMFillToPosition::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMFillToPosition::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMFillToPosition::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - else if (axis == 1) { - return Color(cnv.y, cnv.y, cnv.y, 1); + ClassDB::bind_method(D_METHOD("get_input"), &MMFillToPosition::get_input); + ClassDB::bind_method(D_METHOD("set_input", "value"), &MMFillToPosition::set_input); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); + + ClassDB::bind_method(D_METHOD("get_axis"), &MMFillToPosition::get_axis); + ClassDB::bind_method(D_METHOD("set_axis", "value"), &MMFillToPosition::set_axis); + ADD_PROPERTY(PropertyInfo(Variant::INT, "axis"), "set_axis", "get_axis"); } - - - else if (axis == 2) { - float f = (cnv - Vector2(0.5, 0.5)).length(); - return Color(f, f, f, 1); -} - - return Color(0, 0, 0, 1); -} - - //axis; - - int FillToPosition::get_axis() { - return axis; -} - - - void FillToPosition::set_axis(const int val) { - axis = val; - set_dirty(true); -} - -} - - FillToPosition::FillToPosition() { - image; - input; - axis = 2; - } - - FillToPosition::~FillToPosition() { - } - - - static void FillToPosition::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &FillToPosition::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &FillToPosition::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input"), &FillToPosition::get_input); - ClassDB::bind_method(D_METHOD("set_input", "value"), &FillToPosition::set_input); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - - - ClassDB::bind_method(D_METHOD("get_axis"), &FillToPosition::get_axis); - ClassDB::bind_method(D_METHOD("set_axis", "value"), &FillToPosition::set_axis); - ADD_PROPERTY(PropertyInfo(Variant::INT, "axis"), "set_axis", "get_axis"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &FillToPosition::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &FillToPosition::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &FillToPosition::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &FillToPosition::_get_value_for); - ClassDB::bind_method(D_METHOD("get_axis"), &FillToPosition::get_axis); - ClassDB::bind_method(D_METHOD("set_axis", "val"), &FillToPosition::set_axis); - - } - - - diff --git a/modules/material_maker/nodes/filter/fill_to_position.h b/modules/material_maker/nodes/filter/fill_to_position.h index aed2c8f84..3ed5bc323 100644 --- a/modules/material_maker/nodes/filter/fill_to_position.h +++ b/modules/material_maker/nodes/filter/fill_to_position.h @@ -1,43 +1,37 @@ -#ifndef FILL_TO_POSITION_H -#define FILL_TO_POSITION_H +#ifndef MM_FILL_TO_POSITION_H +#define MM_FILL_TO_POSITION_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class FillToPosition : public MMNode { - GDCLASS(FillToPosition, MMNode); +class MMFillToPosition : public MMNode { + GDCLASS(MMFillToPosition, MMNode); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input(); + void set_input(const Ref &val); - Ref get_input(); - void set_input(const Ref &val); + int get_axis() const; + void set_axis(const int val); - int get_axis() const; - void set_axis(const int val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); - int get_axis(); - void set_axis(const int val); + MMFillToPosition(); + ~MMFillToPosition(); - FillToPosition(); - ~FillToPosition(); +protected: + static void _bind_methods(); - protected: - static void _bind_methods(); - - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref input; - //export(int, "X,Y,Radial") - int axis = 2; - //axis + Ref image; + Ref input; + //export(int, "X,Y,Radial") + int axis; }; - #endif diff --git a/modules/material_maker/nodes/filter/fill_to_random_color.cpp b/modules/material_maker/nodes/filter/fill_to_random_color.cpp index d868d50ec..0ec8758c1 100644 --- a/modules/material_maker/nodes/filter/fill_to_random_color.cpp +++ b/modules/material_maker/nodes/filter/fill_to_random_color.cpp @@ -1,139 +1,97 @@ #include "fill_to_random_color.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref FillToRandomColor::get_image() { - return image; +Ref MMFillToRandomColor::get_image() { + return image; } -void FillToRandomColor::set_image(const Ref &val) { -image = val; +void MMFillToRandomColor::set_image(const Ref &val) { + image = val; } - -Ref FillToRandomColor::get_input() { - return input; +Ref MMFillToRandomColor::get_input() { + return input; } -void FillToRandomColor::set_input(const Ref &val) { -input = val; +void MMFillToRandomColor::set_input(const Ref &val) { + input = val; } - -Color FillToRandomColor::get_edge_color() { - return edge_color; +Color MMFillToRandomColor::get_edge_color() { + return edge_color; } -void FillToRandomColor::set_edge_color(const Color &val) { -edge_color = val; +void MMFillToRandomColor::set_edge_color(const Color &val) { + edge_color = val; + set_dirty(true); } +void MMFillToRandomColor::_init_properties() { + if (!input.is_valid()) { + input.instance(); + input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR); + input->set_default_value(Color(0, 0, 0, 1)); + } + input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input->set_slot_name(">>> Input "); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input; - //export(Color) ; - Color edge_color = Color(1, 1, 1, 1); + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } - void FillToRandomColor::_init_properties() { + //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); + //image.force_override = true; - if (!input) { - input = MMNodeUniversalProperty.new(); - input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; - input.set_default_value(Color(0, 0, 0, 1)); + register_input_property(input); + register_output_property(image); } - input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input.slot_name = ">>> Input "; - - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; +void MMFillToRandomColor::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_label_universal(input); + mm_graph_node->add_slot_texture_universal(image); + mm_graph_node->add_slot_color("get_edge_color", "set_edge_color"); } - //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - //image.force_override = true; - register_input_property(input); - register_output_property(image); +void MMFillToRandomColor::_render(const Ref &material) { + Ref img = render_image(material); + image->set_value(img); } - - void FillToRandomColor::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_label_universal(input); - mm_graph_node.add_slot_texture_universal(image); - mm_graph_node.add_slot_color("get_edge_color", "set_edge_color"); +Color MMFillToRandomColor::_get_value_for(const Vector2 &uv, const int pseed) { + //vec4 $(name_uv)_bb = $in($uv); + Color c = input->get_value(uv); + //mix($edgecolor.rgb, rand3(vec2(float($seed), rand(vec2(rand($(name_uv)_bb.xy), rand($(name_uv)_bb.zw))))), step(0.0000001, dot($(name_uv)_bb.zw, vec2(1.0)))); + float r1 = MMAlgos::rand(Vector2(c.r, c.g)); + float r2 = MMAlgos::rand(Vector2(c.b, c.a)); + float s = MMAlgos::step(0.0000001, Vector2(c.b, c.a).dot(Vector2(1, 1))); + Vector3 f = Vector3(edge_color.r, edge_color.g, edge_color.b).linear_interpolate(MMAlgos::rand3(Vector2(1.0 / float(pseed), MMAlgos::rand(Vector2(r1, r2)))), s); + return Color(f.x, f.y, f.z, 1); } - - void FillToRandomColor::_render(const Variant &material) { - Ref img = render_image(material); - image.set_value(img); +MMFillToRandomColor::MMFillToRandomColor() { + edge_color = Color(1, 1, 1, 1); } - - Color FillToRandomColor::_get_value_for(const Vector2 &uv, const int pseed) { - //vec4 $(name_uv)_bb = $in($uv); - Color c = input.get_value(uv); - //mix($edgecolor.rgb, rand3(vec2(float($seed), rand(vec2(rand($(name_uv)_bb.xy), rand($(name_uv)_bb.zw))))), step(0.0000001, dot($(name_uv)_bb.zw, vec2(1.0)))); - float r1 = MMAlgos.rand(Vector2(c.r, c.g)); - float r2 = MMAlgos.rand(Vector2(c.b, c.a)); - float s = MMAlgos.step(0.0000001, Vector2(c.b, c.a).dot(Vector2(1, 1))); - Vector3 f = lerp(Vector3(edge_color.r, edge_color.g, edge_color.b), MMAlgos.rand3(Vector2(1.0 / float(pseed), MMAlgos.rand(Vector2(r1, r2)))), s); - return Color(f.x, f.y, f.z, 1); +MMFillToRandomColor::~MMFillToRandomColor() { } - //edge_color; +void MMFillToRandomColor::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMFillToRandomColor::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMFillToRandomColor::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_image", "get_image"); - Color FillToRandomColor::get_edge_color() { - return edge_color; + ClassDB::bind_method(D_METHOD("get_input"), &MMFillToRandomColor::get_input); + ClassDB::bind_method(D_METHOD("set_input", "value"), &MMFillToRandomColor::set_input); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input", "get_input"); + + ClassDB::bind_method(D_METHOD("get_edge_color"), &MMFillToRandomColor::get_edge_color); + ClassDB::bind_method(D_METHOD("set_edge_color", "value"), &MMFillToRandomColor::set_edge_color); + ADD_PROPERTY(PropertyInfo(Variant::COLOR, "edge_color"), "set_edge_color", "get_edge_color"); } - - - void FillToRandomColor::set_edge_color(const Color &val) { - edge_color = val; - set_dirty(true); -} - -} - - FillToRandomColor::FillToRandomColor() { - image; - input; - edge_color = Color(1, 1, 1, 1); - } - - FillToRandomColor::~FillToRandomColor() { - } - - - static void FillToRandomColor::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &FillToRandomColor::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &FillToRandomColor::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input"), &FillToRandomColor::get_input); - ClassDB::bind_method(D_METHOD("set_input", "value"), &FillToRandomColor::set_input); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - - - ClassDB::bind_method(D_METHOD("get_edge_color"), &FillToRandomColor::get_edge_color); - ClassDB::bind_method(D_METHOD("set_edge_color", "value"), &FillToRandomColor::set_edge_color); - ADD_PROPERTY(PropertyInfo(Variant::COLOR, "edge_color"), "set_edge_color", "get_edge_color"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &FillToRandomColor::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &FillToRandomColor::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &FillToRandomColor::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &FillToRandomColor::_get_value_for); - ClassDB::bind_method(D_METHOD("get_edge_color"), &FillToRandomColor::get_edge_color); - ClassDB::bind_method(D_METHOD("set_edge_color", "val"), &FillToRandomColor::set_edge_color); - - } - - - diff --git a/modules/material_maker/nodes/filter/fill_to_random_color.h b/modules/material_maker/nodes/filter/fill_to_random_color.h index a49607713..ac081e376 100644 --- a/modules/material_maker/nodes/filter/fill_to_random_color.h +++ b/modules/material_maker/nodes/filter/fill_to_random_color.h @@ -1,43 +1,36 @@ -#ifndef FILL_TO_RANDOM_COLOR_H -#define FILL_TO_RANDOM_COLOR_H +#ifndef MM_FILL_TO_RANDOM_COLOR_H +#define MM_FILL_TO_RANDOM_COLOR_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class FillToRandomColor : public MMNode { - GDCLASS(FillToRandomColor, MMNode); +class MMFillToRandomColor : public MMNode { + GDCLASS(MMFillToRandomColor, MMNode); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input(); + void set_input(const Ref &val); - Ref get_input(); - void set_input(const Ref &val); + Color get_edge_color(); + void set_edge_color(const Color &val); - Color get_edge_color(); - void set_edge_color(const Color &val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); - Color get_edge_color(); - void set_edge_color(const Color &val); + MMFillToRandomColor(); + ~MMFillToRandomColor(); - FillToRandomColor(); - ~FillToRandomColor(); +protected: + static void _bind_methods(); - protected: - static void _bind_methods(); - - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref input; - //export(Color) - Color edge_color = Color(1, 1, 1, 1); - //edge_color + Ref image; + Ref input; + Color edge_color; }; - #endif diff --git a/modules/material_maker/nodes/filter/fill_to_random_grey.cpp b/modules/material_maker/nodes/filter/fill_to_random_grey.cpp index addc65b24..34053ef92 100644 --- a/modules/material_maker/nodes/filter/fill_to_random_grey.cpp +++ b/modules/material_maker/nodes/filter/fill_to_random_grey.cpp @@ -1,139 +1,96 @@ #include "fill_to_random_grey.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref FillToRandomGrey::get_image() { - return image; +Ref MMFillToRandomGrey::get_image() { + return image; } -void FillToRandomGrey::set_image(const Ref &val) { -image = val; +void MMFillToRandomGrey::set_image(const Ref &val) { + image = val; } - -Ref FillToRandomGrey::get_input() { - return input; +Ref MMFillToRandomGrey::get_input() { + return input; } -void FillToRandomGrey::set_input(const Ref &val) { -input = val; +void MMFillToRandomGrey::set_input(const Ref &val) { + input = val; } - -float FillToRandomGrey::get_edge_color() const { - return edge_color; +float MMFillToRandomGrey::get_edge_color() const { + return edge_color; } -void FillToRandomGrey::set_edge_color(const float val) { -edge_color = val; +void MMFillToRandomGrey::set_edge_color(const float val) { + edge_color = val; + set_dirty(true); } +void MMFillToRandomGrey::_init_properties() { + if (!input.is_valid()) { + input.instance(); + input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR); + input->set_default_value(Color(0, 0, 0, 1)); + } + input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input->set_slot_name(">>> Input "); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input; - //export(float) ; - float edge_color = 1; + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } - void FillToRandomGrey::_init_properties() { - - if (!input) { - input = MMNodeUniversalProperty.new(); - input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; - input.set_default_value(Color(0, 0, 0, 1)); + //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); + //image.force_override = true; + register_input_property(input); + register_output_property(image); } - input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input.slot_name = ">>> Input "; - - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; +void MMFillToRandomGrey::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_label_universal(input); + mm_graph_node->add_slot_texture_universal(image); + mm_graph_node->add_slot_float("get_edge_color", "set_edge_color", "Edge color", 0.01); } - //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - //image.force_override = true; - register_input_property(input); - register_output_property(image); +void MMFillToRandomGrey::_render(const Ref &material) { + Ref img = render_image(material); + image->set_value(img); } - - void FillToRandomGrey::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_label_universal(input); - mm_graph_node.add_slot_texture_universal(image); - mm_graph_node.add_slot_float("get_edge_color", "set_edge_color", "Edge color", 0.01); +Color MMFillToRandomGrey::_get_value_for(const Vector2 &uv, const int pseed) { + //vec4 $(name_uv)_bb = $in($uv); + Color c = input->get_value(uv); + //mix($edgecolor, rand(vec2(float($seed), rand(vec2(rand($(name_uv)_bb.xy), rand($(name_uv)_bb.zw))))), step(0.0000001, dot($(name_uv)_bb.zw, vec2(1.0)))); + float r1 = MMAlgos::rand(Vector2(c.r, c.g)); + float r2 = MMAlgos::rand(Vector2(c.b, c.a)); + float s = MMAlgos::step(0.0000001, Vector2(c.b, c.a).dot(Vector2(1, 1))); + float f = Math::lerp(edge_color, MMAlgos::rand(Vector2(1.0 / float(pseed), MMAlgos::rand(Vector2(r1, r2)))), s); + return Color(f, f, f, 1); } - - void FillToRandomGrey::_render(const Variant &material) { - Ref img = render_image(material); - image.set_value(img); +MMFillToRandomGrey::MMFillToRandomGrey() { + edge_color = 1; } - - Color FillToRandomGrey::_get_value_for(const Vector2 &uv, const int pseed) { - //vec4 $(name_uv)_bb = $in($uv); - Color c = input.get_value(uv); - //mix($edgecolor, rand(vec2(float($seed), rand(vec2(rand($(name_uv)_bb.xy), rand($(name_uv)_bb.zw))))), step(0.0000001, dot($(name_uv)_bb.zw, vec2(1.0)))); - float r1 = MMAlgos.rand(Vector2(c.r, c.g)); - float r2 = MMAlgos.rand(Vector2(c.b, c.a)); - float s = MMAlgos.step(0.0000001, Vector2(c.b, c.a).dot(Vector2(1, 1))); - float f = lerp(edge_color, MMAlgos.rand(Vector2(1.0 / float(pseed), MMAlgos.rand(Vector2(r1, r2)))), s); - return Color(f, f, f, 1); +MMFillToRandomGrey::~MMFillToRandomGrey() { } - //edge_color; +void MMFillToRandomGrey::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMFillToRandomGrey::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMFillToRandomGrey::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_image", "get_image"); - float FillToRandomGrey::get_edge_color() { - return edge_color; + ClassDB::bind_method(D_METHOD("get_input"), &MMFillToRandomGrey::get_input); + ClassDB::bind_method(D_METHOD("set_input", "value"), &MMFillToRandomGrey::set_input); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input", "get_input"); + + ClassDB::bind_method(D_METHOD("get_edge_color"), &MMFillToRandomGrey::get_edge_color); + ClassDB::bind_method(D_METHOD("set_edge_color", "value"), &MMFillToRandomGrey::set_edge_color); + ADD_PROPERTY(PropertyInfo(Variant::REAL, "edge_color"), "set_edge_color", "get_edge_color"); } - - - void FillToRandomGrey::set_edge_color(const float val) { - edge_color = val; - set_dirty(true); -} - -} - - FillToRandomGrey::FillToRandomGrey() { - image; - input; - edge_color = 1; - } - - FillToRandomGrey::~FillToRandomGrey() { - } - - - static void FillToRandomGrey::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &FillToRandomGrey::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &FillToRandomGrey::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input"), &FillToRandomGrey::get_input); - ClassDB::bind_method(D_METHOD("set_input", "value"), &FillToRandomGrey::set_input); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - - - ClassDB::bind_method(D_METHOD("get_edge_color"), &FillToRandomGrey::get_edge_color); - ClassDB::bind_method(D_METHOD("set_edge_color", "value"), &FillToRandomGrey::set_edge_color); - ADD_PROPERTY(PropertyInfo(Variant::REAL, "edge_color"), "set_edge_color", "get_edge_color"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &FillToRandomGrey::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &FillToRandomGrey::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &FillToRandomGrey::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &FillToRandomGrey::_get_value_for); - ClassDB::bind_method(D_METHOD("get_edge_color"), &FillToRandomGrey::get_edge_color); - ClassDB::bind_method(D_METHOD("set_edge_color", "val"), &FillToRandomGrey::set_edge_color); - - } - - - diff --git a/modules/material_maker/nodes/filter/fill_to_random_grey.h b/modules/material_maker/nodes/filter/fill_to_random_grey.h index 6cd369987..d5abe5246 100644 --- a/modules/material_maker/nodes/filter/fill_to_random_grey.h +++ b/modules/material_maker/nodes/filter/fill_to_random_grey.h @@ -1,43 +1,36 @@ -#ifndef FILL_TO_RANDOM_GREY_H -#define FILL_TO_RANDOM_GREY_H +#ifndef MM_FILL_TO_RANDOM_GREY_H +#define MM_FILL_TO_RANDOM_GREY_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class FillToRandomGrey : public MMNode { - GDCLASS(FillToRandomGrey, MMNode); +class MMFillToRandomGrey : public MMNode { + GDCLASS(MMFillToRandomGrey, MMNode); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input(); + void set_input(const Ref &val); - Ref get_input(); - void set_input(const Ref &val); + float get_edge_color() const; + void set_edge_color(const float val); - float get_edge_color() const; - void set_edge_color(const float val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); - float get_edge_color(); - void set_edge_color(const float val); + MMFillToRandomGrey(); + ~MMFillToRandomGrey(); - FillToRandomGrey(); - ~FillToRandomGrey(); +protected: + static void _bind_methods(); - protected: - static void _bind_methods(); - - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref input; - //export(float) - float edge_color = 1; - //edge_color + Ref image; + Ref input; + float edge_color; }; - #endif diff --git a/modules/material_maker/nodes/filter/fill_to_size.cpp b/modules/material_maker/nodes/filter/fill_to_size.cpp index 9676bfc0e..bec753bfa 100644 --- a/modules/material_maker/nodes/filter/fill_to_size.cpp +++ b/modules/material_maker/nodes/filter/fill_to_size.cpp @@ -1,159 +1,114 @@ #include "fill_to_size.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref FillToSize::get_image() { - return image; +Ref MMFillToSize::get_image() { + return image; } -void FillToSize::set_image(const Ref &val) { -image = val; +void MMFillToSize::set_image(const Ref &val) { + image = val; } - -Ref FillToSize::get_input() { - return input; +Ref MMFillToSize::get_input() { + return input; } -void FillToSize::set_input(const Ref &val) { -input = val; +void MMFillToSize::set_input(const Ref &val) { + input = val; } - -int FillToSize::get_formula() const { - return formula; +int MMFillToSize::get_formula() const { + return formula; } -void FillToSize::set_formula(const int val) { -formula = val; +void MMFillToSize::set_formula(const int val) { + formula = val; + set_dirty(true); } +void MMFillToSize::_init_properties() { + if (!input.is_valid()) { + input.instance(); + input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR); + input->set_default_value(Color(0, 0, 0, 1)); + } + input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input->set_slot_name(">>> Input "); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input; - //export(int, "Area,Width,Height,Max(W,H)") ; - int formula = 0; + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } - void FillToSize::_init_properties() { - - if (!input) { - input = MMNodeUniversalProperty.new(); - input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; - input.set_default_value(Color(0, 0, 0, 1)); + //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); + //image.force_override = true; + register_input_property(input); + register_output_property(image); } - input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input.slot_name = ">>> Input "; +void MMFillToSize::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_label_universal(input); + mm_graph_node->add_slot_texture_universal(image); - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; + Array arr; + arr.push_back("Area"); + arr.push_back("Width"); + arr.push_back("Height"); + arr.push_back("Max(W,H)"); + + mm_graph_node->add_slot_enum("get_formula", "set_formula", "Formula", arr); } - //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - //image.force_override = true; - register_input_property(input); - register_output_property(image); +void MMFillToSize::_render(const Ref &material) { + Ref img = render_image(material); + image->set_value(img); } +Color MMFillToSize::_get_value_for(const Vector2 &uv, const int pseed) { + //vec4 $(name_uv)_bb = $in($uv); + Color c = input->get_value(uv); + float f = 0; + //"Area" sqrt($(name_uv)_bb.z*$(name_uv)_bb.w); + //"Width" $(name_uv)_bb.z; + //"Height" $(name_uv)_bb.w; + //"max(W, H)" max($(name_uv)_bb.z, $(name_uv)_bb.w); - void FillToSize::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_label_universal(input); - mm_graph_node.add_slot_texture_universal(image); - mm_graph_node.add_slot_enum("get_formula", "set_formula", "Formula", [ "Area", "Width", "Height", "Max(W,H)" ]); + if (formula == 0) { + f = sqrt(c.b * c.a); + } else if (formula == 1) { + f = c.b; + } else if (formula == 2) { + f = c.a; + } else if (formula == 3) { + f = MAX(c.b, c.a); + } + + return Color(f, f, f, 1); } - - void FillToSize::_render(const Variant &material) { - Ref img = render_image(material); - image.set_value(img); +MMFillToSize::MMFillToSize() { + formula = 0; } - - Color FillToSize::_get_value_for(const Vector2 &uv, const int pseed) { - //vec4 $(name_uv)_bb = $in($uv); - Color c = input.get_value(uv); - float f = 0; - //"Area" sqrt($(name_uv)_bb.z*$(name_uv)_bb.w); - //"Width" $(name_uv)_bb.z; - //"Height" $(name_uv)_bb.w; - //"max(W, H)" max($(name_uv)_bb.z, $(name_uv)_bb.w); - - if (formula == 0) { - f = sqrt(c.b * c.a); +MMFillToSize::~MMFillToSize() { } +void MMFillToSize::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMFillToSize::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMFillToSize::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_image", "get_image"); - else if (formula == 1) { - f = c.b; + ClassDB::bind_method(D_METHOD("get_input"), &MMFillToSize::get_input); + ClassDB::bind_method(D_METHOD("set_input", "value"), &MMFillToSize::set_input); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input", "get_input"); + + ClassDB::bind_method(D_METHOD("get_formula"), &MMFillToSize::get_formula); + ClassDB::bind_method(D_METHOD("set_formula", "value"), &MMFillToSize::set_formula); + ADD_PROPERTY(PropertyInfo(Variant::INT, "formula"), "set_formula", "get_formula"); } - - - else if (formula == 2) { - f = c.a; -} - - - else if (formula == 3) { - f = max(c.b, c.a); -} - - return Color(f, f, f, 1); -} - - //formula; - - int FillToSize::get_formula() { - return formula; -} - - - void FillToSize::set_formula(const int val) { - formula = val; - set_dirty(true); -} - -} - - FillToSize::FillToSize() { - image; - input; - formula = 0; - } - - FillToSize::~FillToSize() { - } - - - static void FillToSize::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &FillToSize::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &FillToSize::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input"), &FillToSize::get_input); - ClassDB::bind_method(D_METHOD("set_input", "value"), &FillToSize::set_input); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - - - ClassDB::bind_method(D_METHOD("get_formula"), &FillToSize::get_formula); - ClassDB::bind_method(D_METHOD("set_formula", "value"), &FillToSize::set_formula); - ADD_PROPERTY(PropertyInfo(Variant::INT, "formula"), "set_formula", "get_formula"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &FillToSize::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &FillToSize::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &FillToSize::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &FillToSize::_get_value_for); - ClassDB::bind_method(D_METHOD("get_formula"), &FillToSize::get_formula); - ClassDB::bind_method(D_METHOD("set_formula", "val"), &FillToSize::set_formula); - - } - - - diff --git a/modules/material_maker/nodes/filter/fill_to_size.h b/modules/material_maker/nodes/filter/fill_to_size.h index 1c4db9c95..50817d9c3 100644 --- a/modules/material_maker/nodes/filter/fill_to_size.h +++ b/modules/material_maker/nodes/filter/fill_to_size.h @@ -1,43 +1,37 @@ -#ifndef FILL_TO_SIZE_H -#define FILL_TO_SIZE_H +#ifndef MM_FILL_TO_SIZE_H +#define MM_FILL_TO_SIZE_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class FillToSize : public MMNode { - GDCLASS(FillToSize, MMNode); +class MMFillToSize : public MMNode { + GDCLASS(MMFillToSize, MMNode); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input(); + void set_input(const Ref &val); - Ref get_input(); - void set_input(const Ref &val); + int get_formula() const; + void set_formula(const int val); - int get_formula() const; - void set_formula(const int val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); - int get_formula(); - void set_formula(const int val); + MMFillToSize(); + ~MMFillToSize(); - FillToSize(); - ~FillToSize(); +protected: + static void _bind_methods(); - protected: - static void _bind_methods(); - - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref input; - //export(int, "Area,Width,Height,Max(W,H)") - int formula = 0; - //formula + Ref image; + Ref input; + //export(int, "Area,Width,Height,Max(W,H)") + int formula; }; - #endif diff --git a/modules/material_maker/nodes/filter/fill_to_uv.cpp b/modules/material_maker/nodes/filter/fill_to_uv.cpp index 157d9e105..a6692b280 100644 --- a/modules/material_maker/nodes/filter/fill_to_uv.cpp +++ b/modules/material_maker/nodes/filter/fill_to_uv.cpp @@ -1,146 +1,106 @@ #include "fill_to_uv.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref FillToUv::get_image() { - return image; +Ref MMFillToUv::get_image() { + return image; } -void FillToUv::set_image(const Ref &val) { -image = val; +void MMFillToUv::set_image(const Ref &val) { + image = val; } - -Ref FillToUv::get_input() { - return input; +Ref MMFillToUv::get_input() { + return input; } -void FillToUv::set_input(const Ref &val) { -input = val; +void MMFillToUv::set_input(const Ref &val) { + input = val; } - -int FillToUv::get_mode() const { - return mode; +int MMFillToUv::get_mode() const { + return mode; } -void FillToUv::set_mode(const int val) { -mode = val; +void MMFillToUv::set_mode(const int val) { + mode = val; + set_dirty(true); } +void MMFillToUv::_init_properties() { + if (!input.is_valid()) { + input.instance(); + input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR); + input->set_default_value(Color(0, 0, 0, 1)); + } + input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input->set_slot_name(">>> Input "); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input; - //export(int, "Stretch,Square") ; - int mode = 0; + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } - void FillToUv::_init_properties() { + //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); + //image.force_override = true; - if (!input) { - input = MMNodeUniversalProperty.new(); - input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; - input.set_default_value(Color(0, 0, 0, 1)); + register_input_property(input); + register_output_property(image); } - input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input.slot_name = ">>> Input "; +void MMFillToUv::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_label_universal(input); + mm_graph_node->add_slot_texture_universal(image); - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; + Array arr; + arr.push_back("Stretch"); + arr.push_back("Square"); + + mm_graph_node->add_slot_enum("get_mode", "set_mode", "Mode", arr); } - //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - //image.force_override = true; - register_input_property(input); - register_output_property(image); +void MMFillToUv::_render(const Ref &material) { + Ref img = render_image(material); + image->set_value(img); } +Color MMFillToUv::_get_value_for(const Vector2 &uv, const int pseed) { + //vec4 $(name_uv)_bb = $in($uv); + Color c = input->get_value(uv); + //fill_to_uv_$mode($uv, $(name_uv)_bb, float($seed)); + Vector3 r = Vector3(); - void FillToUv::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_label_universal(input); - mm_graph_node.add_slot_texture_universal(image); - mm_graph_node.add_slot_enum("get_mode", "set_mode", "Mode", [ "Stretch", "Square" ]); + if (mode == 0) { + r = MMAlgos::fill_to_uv_stretch(uv, c, float(pseed)); + } else if (mode == 1) { + r = MMAlgos::fill_to_uv_square(uv, c, float(pseed)); + } + + return Color(r.x, r.y, r.z, 1); } - - void FillToUv::_render(const Variant &material) { - Ref img = render_image(material); - image.set_value(img); +MMFillToUv::MMFillToUv() { + mode = 0; } - - Color FillToUv::_get_value_for(const Vector2 &uv, const int pseed) { - //vec4 $(name_uv)_bb = $in($uv); - Color c = input.get_value(uv); - //fill_to_uv_$mode($uv, $(name_uv)_bb, float($seed)); - Vector3 r = Vector3(); - - if (mode == 0) { - r = MMAlgos.fill_to_uv_stretch(uv, c, float(pseed)); +MMFillToUv::~MMFillToUv() { } +void MMFillToUv::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMFillToUv::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMFillToUv::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_image", "get_image"); - else if (mode == 1) { - r = MMAlgos.fill_to_uv_square(uv, c, float(pseed)); + ClassDB::bind_method(D_METHOD("get_input"), &MMFillToUv::get_input); + ClassDB::bind_method(D_METHOD("set_input", "value"), &MMFillToUv::set_input); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input", "get_input"); + + ClassDB::bind_method(D_METHOD("get_mode"), &MMFillToUv::get_mode); + ClassDB::bind_method(D_METHOD("set_mode", "value"), &MMFillToUv::set_mode); + ADD_PROPERTY(PropertyInfo(Variant::INT, "mode"), "set_mode", "get_mode"); } - - return Color(r.x, r.y, r.z, 1); -} - - //mode; - - int FillToUv::get_mode() { - return mode; -} - - - void FillToUv::set_mode(const int val) { - mode = val; - set_dirty(true); -} - -} - - FillToUv::FillToUv() { - image; - input; - mode = 0; - } - - FillToUv::~FillToUv() { - } - - - static void FillToUv::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &FillToUv::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &FillToUv::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input"), &FillToUv::get_input); - ClassDB::bind_method(D_METHOD("set_input", "value"), &FillToUv::set_input); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - - - ClassDB::bind_method(D_METHOD("get_mode"), &FillToUv::get_mode); - ClassDB::bind_method(D_METHOD("set_mode", "value"), &FillToUv::set_mode); - ADD_PROPERTY(PropertyInfo(Variant::INT, "mode"), "set_mode", "get_mode"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &FillToUv::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &FillToUv::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &FillToUv::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &FillToUv::_get_value_for); - ClassDB::bind_method(D_METHOD("get_mode"), &FillToUv::get_mode); - ClassDB::bind_method(D_METHOD("set_mode", "val"), &FillToUv::set_mode); - - } - - - diff --git a/modules/material_maker/nodes/filter/fill_to_uv.h b/modules/material_maker/nodes/filter/fill_to_uv.h index a10442c30..9e7d4a74c 100644 --- a/modules/material_maker/nodes/filter/fill_to_uv.h +++ b/modules/material_maker/nodes/filter/fill_to_uv.h @@ -1,43 +1,37 @@ -#ifndef FILL_TO_UV_H -#define FILL_TO_UV_H +#ifndef MM_FILL_TO_UV_H +#define MM_FILL_TO_UV_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class FillToUv : public MMNode { - GDCLASS(FillToUv, MMNode); +class MMFillToUv : public MMNode { + GDCLASS(MMFillToUv, MMNode); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input(); + void set_input(const Ref &val); - Ref get_input(); - void set_input(const Ref &val); + int get_mode() const; + void set_mode(const int val); - int get_mode() const; - void set_mode(const int val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); - int get_mode(); - void set_mode(const int val); + MMFillToUv(); + ~MMFillToUv(); - FillToUv(); - ~FillToUv(); +protected: + static void _bind_methods(); - protected: - static void _bind_methods(); - - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref input; - //export(int, "Stretch,Square") - int mode = 0; - //mode + Ref image; + Ref input; + //export(int, "Stretch,Square") + int mode; }; - #endif diff --git a/modules/material_maker/nodes/filter/greyscale.cpp b/modules/material_maker/nodes/filter/greyscale.cpp index 65ddea934..644bcedc8 100644 --- a/modules/material_maker/nodes/filter/greyscale.cpp +++ b/modules/material_maker/nodes/filter/greyscale.cpp @@ -1,159 +1,113 @@ #include "greyscale.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref Greyscale::get_image() { - return image; +Ref MMGreyscale::get_image() { + return image; } -void Greyscale::set_image(const Ref &val) { -image = val; +void MMGreyscale::set_image(const Ref &val) { + image = val; } - -Ref Greyscale::get_input() { - return input; +Ref MMGreyscale::get_input() { + return input; } -void Greyscale::set_input(const Ref &val) { -input = val; +void MMGreyscale::set_input(const Ref &val) { + input = val; } - -int Greyscale::get_type() const { - return type; +int MMGreyscale::get_type() const { + return type; } -void Greyscale::set_type(const int val) { -type = val; +void MMGreyscale::set_type(const int val) { + type = val; + set_dirty(true); } +void MMGreyscale::_init_properties() { + if (!input.is_valid()) { + input.instance(); + input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR); + input->set_default_value(Color(0, 0, 0, 1)); + } + input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input->set_slot_name(">>> Input1 "); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input; - //export(int, "Lightness,Average,Luminosity,Min,Max") ; - int type = 2; + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } - void Greyscale::_init_properties() { + //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); + //image.force_override = true; - if (!input) { - input = MMNodeUniversalProperty.new(); - input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; - input.set_default_value(Color(0, 0, 0, 1)); + register_input_property(input); + register_output_property(image); } - input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input.slot_name = ">>> Input1 "; +void MMGreyscale::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_label_universal(input); + mm_graph_node->add_slot_texture_universal(image); - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; + Array arr; + arr.push_back("Lightness"); + arr.push_back("Average"); + arr.push_back("Luminosity"); + arr.push_back("Min"); + arr.push_back("Max"); + + mm_graph_node->add_slot_enum("get_type", "set_type", "Type", arr); } - //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - //image.force_override = true; - register_input_property(input); - register_output_property(image); +void MMGreyscale::_render(const Ref &material) { + Ref img = render_image(material); + image->set_value(img); } +Color MMGreyscale::_get_value_for(const Vector2 &uv, const int pseed) { + Color c = input->get_value(uv); + float f = 0; - void Greyscale::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_label_universal(input); - mm_graph_node.add_slot_texture_universal(image); - mm_graph_node.add_slot_enum("get_type", "set_type", "Type", [ "Lightness", "Average", "Luminosity", "Min", "Max" ]); + if (type == 0) { + f = MMAlgos::grayscale_lightness(Vector3(c.r, c.g, c.b)); + } else if (type == 1) { + f = MMAlgos::grayscale_average(Vector3(c.r, c.g, c.b)); + } else if (type == 2) { + f = MMAlgos::grayscale_luminosity(Vector3(c.r, c.g, c.b)); + } else if (type == 3) { + f = MMAlgos::grayscale_min(Vector3(c.r, c.g, c.b)); + } else if (type == 4) { + f = MMAlgos::grayscale_max(Vector3(c.r, c.g, c.b)); + } + + return Color(f, f, f, c.a); } - - void Greyscale::_render(const Variant &material) { - Ref img = render_image(material); - image.set_value(img); +MMGreyscale::MMGreyscale() { + type = 2; } - - Color Greyscale::_get_value_for(const Vector2 &uv, const int pseed) { - Color c = input.get_value(uv); - float f = 0; - - if (type == 0) { - f = MMAlgos.grayscale_lightness(Vector3(c.r, c.g, c.b)); +MMGreyscale::~MMGreyscale() { } +void MMGreyscale::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMGreyscale::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMGreyscale::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_image", "get_image"); - else if (type == 1) { - f = MMAlgos.grayscale_average(Vector3(c.r, c.g, c.b)); + ClassDB::bind_method(D_METHOD("get_input"), &MMGreyscale::get_input); + ClassDB::bind_method(D_METHOD("set_input", "value"), &MMGreyscale::set_input); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input", "get_input"); + + ClassDB::bind_method(D_METHOD("get_type"), &MMGreyscale::get_type); + ClassDB::bind_method(D_METHOD("set_type", "value"), &MMGreyscale::set_type); + ADD_PROPERTY(PropertyInfo(Variant::INT, "type"), "set_type", "get_type"); } - - - else if (type == 2) { - f = MMAlgos.grayscale_luminosity(Vector3(c.r, c.g, c.b)); -} - - - else if (type == 3) { - f = MMAlgos.grayscale_min(Vector3(c.r, c.g, c.b)); -} - - - else if (type == 4) { - f = MMAlgos.grayscale_max(Vector3(c.r, c.g, c.b)); -} - - return Color(f, f, f, c.a); -} - - //type; - - int Greyscale::get_type() { - return type; -} - - - void Greyscale::set_type(const int val) { - type = val; - set_dirty(true); -} - -} - - Greyscale::Greyscale() { - image; - input; - type = 2; - } - - Greyscale::~Greyscale() { - } - - - static void Greyscale::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &Greyscale::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &Greyscale::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input"), &Greyscale::get_input); - ClassDB::bind_method(D_METHOD("set_input", "value"), &Greyscale::set_input); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - - - ClassDB::bind_method(D_METHOD("get_type"), &Greyscale::get_type); - ClassDB::bind_method(D_METHOD("set_type", "value"), &Greyscale::set_type); - ADD_PROPERTY(PropertyInfo(Variant::INT, "type"), "set_type", "get_type"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &Greyscale::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &Greyscale::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &Greyscale::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &Greyscale::_get_value_for); - ClassDB::bind_method(D_METHOD("get_type"), &Greyscale::get_type); - ClassDB::bind_method(D_METHOD("set_type", "val"), &Greyscale::set_type); - - } - - - diff --git a/modules/material_maker/nodes/filter/greyscale.h b/modules/material_maker/nodes/filter/greyscale.h index 39e9ef743..f35398ec8 100644 --- a/modules/material_maker/nodes/filter/greyscale.h +++ b/modules/material_maker/nodes/filter/greyscale.h @@ -1,43 +1,37 @@ -#ifndef GREYSCALE_H -#define GREYSCALE_H +#ifndef MM_GREYSCALE_H +#define MM_GREYSCALE_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class Greyscale : public MMNode { - GDCLASS(Greyscale, MMNode); +class MMGreyscale : public MMNode { + GDCLASS(MMGreyscale, MMNode); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input(); + void set_input(const Ref &val); - Ref get_input(); - void set_input(const Ref &val); + int get_type() const; + void set_type(const int val); - int get_type() const; - void set_type(const int val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); - int get_type(); - void set_type(const int val); + MMGreyscale(); + ~MMGreyscale(); - Greyscale(); - ~Greyscale(); +protected: + static void _bind_methods(); - protected: - static void _bind_methods(); - - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref input; - //export(int, "Lightness,Average,Luminosity,Min,Max") - int type = 2; - //type + Ref image; + Ref input; + //export(int, "Lightness,Average,Luminosity,Min,Max") + int type; }; - #endif diff --git a/modules/material_maker/nodes/filter/invert.cpp b/modules/material_maker/nodes/filter/invert.cpp index b4d9fc6da..459a77e6c 100644 --- a/modules/material_maker/nodes/filter/invert.cpp +++ b/modules/material_maker/nodes/filter/invert.cpp @@ -1,101 +1,75 @@ #include "invert.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref Invert::get_image() { - return image; +Ref MMInvert::get_image() { + return image; } -void Invert::set_image(const Ref &val) { -image = val; +void MMInvert::set_image(const Ref &val) { + image = val; } - -Ref Invert::get_input() { - return input; +Ref MMInvert::get_input() { + return input; } -void Invert::set_input(const Ref &val) { -input = val; +void MMInvert::set_input(const Ref &val) { + input = val; } +void MMInvert::_init_properties() { + if (!input.is_valid()) { + input.instance(); + input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR); + input->set_default_value(Color(0, 0, 0, 1)); + } + input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input->set_slot_name(">>> Input1 "); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input; + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } - void Invert::_init_properties() { - - if (!input) { - input = MMNodeUniversalProperty.new(); - input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; - input.set_default_value(Color(0, 0, 0, 1)); + //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); + //image.force_override = true; + register_input_property(input); + register_output_property(image); } - input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input.slot_name = ">>> Input1 "; - - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; +void MMInvert::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_label_universal(input); + mm_graph_node->add_slot_texture_universal(image); } - //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - //image.force_override = true; - register_input_property(input); - register_output_property(image); +void MMInvert::_render(const Ref &material) { + Ref img = render_image(material); + image->set_value(img); } - - void Invert::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_label_universal(input); - mm_graph_node.add_slot_texture_universal(image); +Color MMInvert::_get_value_for(const Vector2 &uv, const int pseed) { + Color c = input->get_value(uv); + return MMAlgos::invert(c); } - - void Invert::_render(const Variant &material) { - Ref img = render_image(material); - image.set_value(img); +MMInvert::MMInvert() { } - - Color Invert::_get_value_for(const Vector2 &uv, const int pseed) { - Color c = input.get_value(uv); - return MMAlgos.invert(c); +MMInvert::~MMInvert() { } +void MMInvert::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMInvert::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMInvert::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_image", "get_image"); + + ClassDB::bind_method(D_METHOD("get_input"), &MMInvert::get_input); + ClassDB::bind_method(D_METHOD("set_input", "value"), &MMInvert::set_input); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input", "get_input"); } - - Invert::Invert() { - image; - input; - } - - Invert::~Invert() { - } - - - static void Invert::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &Invert::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &Invert::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input"), &Invert::get_input); - ClassDB::bind_method(D_METHOD("set_input", "value"), &Invert::set_input); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &Invert::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &Invert::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &Invert::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &Invert::_get_value_for); - - } - - - diff --git a/modules/material_maker/nodes/filter/invert.h b/modules/material_maker/nodes/filter/invert.h index 2e333ae01..1c3cebf74 100644 --- a/modules/material_maker/nodes/filter/invert.h +++ b/modules/material_maker/nodes/filter/invert.h @@ -1,35 +1,35 @@ -#ifndef INVERT_H -#define INVERT_H +#ifndef MM_INVERT_H +#define MM_INVERT_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class Invert : public MMNode { - GDCLASS(Invert, MMNode); +class MMInvert : public MMNode { + GDCLASS(MMInvert, MMNode); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input(); + void set_input(const Ref &val); - Ref get_input(); - void set_input(const Ref &val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); + MMInvert(); + ~MMInvert(); - Invert(); - ~Invert(); +protected: + static void _bind_methods(); - protected: - static void _bind_methods(); - - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref input; + //tool + //export(MMNodeUniversalProperty) + Ref image; + //export(MMNodeUniversalProperty) + Ref input; }; - #endif diff --git a/modules/material_maker/nodes/filter/make_tileable.cpp b/modules/material_maker/nodes/filter/make_tileable.cpp index cee190d48..297ed525f 100644 --- a/modules/material_maker/nodes/filter/make_tileable.cpp +++ b/modules/material_maker/nodes/filter/make_tileable.cpp @@ -1,168 +1,125 @@ #include "make_tileable.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref MakeTileable::get_image() { - return image; +Ref MMMakeTileable::get_image() { + return image; } -void MakeTileable::set_image(const Ref &val) { -image = val; +void MMMakeTileable::set_image(const Ref &val) { + image = val; } - -Ref MakeTileable::get_input() { - return input; +Ref MMMakeTileable::get_input() { + return input; } -void MakeTileable::set_input(const Ref &val) { -input = val; +void MMMakeTileable::set_input(const Ref &val) { + input = val; } - -float MakeTileable::get_width() const { - return width; +float MMMakeTileable::get_width() const { + return width; } -void MakeTileable::set_width(const float val) { -width = val; +void MMMakeTileable::set_width(const float val) { + width = val; + set_dirty(true); } - -int MakeTileable::get_size() const { - return size; +int MMMakeTileable::get_size() const { + return size; } -void MakeTileable::set_size(const int val) { -size = val; +void MMMakeTileable::set_size(const int val) { + size = val; + set_dirty(true); } +void MMMakeTileable::_init_properties() { + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input; - //export(float) ; - float width = 0.1; - int size = 0; + if (!input.is_valid()) { + input.instance(); + input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR); + input->set_default_value(Color()); + } - void MakeTileable::_init_properties() { - - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; + input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input->set_slot_name(">>> Input1 "); + register_input_property(input); + register_output_property(image); } - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - - if (!input) { - input = MMNodeUniversalProperty.new(); - input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; - input.set_default_value(Color()); +void MMMakeTileable::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_texture_universal(image); + mm_graph_node->add_slot_label_universal(input); + mm_graph_node->add_slot_float("get_width", "set_width", "Width", 0.01); } - input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input.slot_name = ">>> Input1 "; - register_input_property(input); - register_output_property(image); +void MMMakeTileable::_render(const Ref &material) { + size = MAX(material->image_size.x, material->image_size.y); + Ref img = render_image(material); + image->set_value(img); } - - void MakeTileable::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_texture_universal(image); - mm_graph_node.add_slot_label_universal(input); - mm_graph_node.add_slot_float("get_width", "set_width", "Width", 0.01); +Color MMMakeTileable::_get_value_for(const Vector2 &uv, const int pseed) { + //make_tileable_$(name)($uv, 0.5*$w); + return make_tileable(uv, 0.5 * width); } +//----------------------; +//make_tileable.mmg; +//vec4 make_tileable_$(name)(vec2 uv, float w) {; +// vec4 a = $in(uv); +// vec4 b = $in(fract(uv+vec2(0.5))); +// float coef_ab = sin(1.57079632679*clamp((length(uv-vec2(0.5))-0.5+w)/w, 0.0, 1.0)); +// vec4 c = $in(fract(uv+vec2(0.25))); +// float coef_abc = sin(1.57079632679*clamp((min(min(length(uv-vec2(0.0, 0.5)), length(uv-vec2(0.5, 0.0))), min(length(uv-vec2(1.0, 0.5)), length(uv-vec2(0.5, 1.0))))-w)/w, 0.0, 1.0)); +// return mix(c, mix(a, b, coef_ab), coef_abc); +//}; - void MakeTileable::_render(const Variant &material) { - size = max(material.image_size.x, material.image_size.y); - Ref img = render_image(material); - image.set_value(img); +Color MMMakeTileable::make_tileable(const Vector2 &uv, const float w) { + Color a = input->get_value(uv); + Color b = input->get_value(MMAlgos::fractv2(uv + Vector2(0.5, 0.5))); + float coef_ab = Math::sin(1.57079632679 * CLAMP(((uv - Vector2(0.5, 0.5)).length() - 0.5 + w) / w, 0.0, 1.0)); + Color c = input->get_value(MMAlgos::fractv2(uv + Vector2(0.25, 0.25))); + float coef_abc = sin(1.57079632679 * CLAMP((MIN(MIN((uv - Vector2(0.0, 0.5)).length(), (uv - Vector2(0.5, 0.0)).length()), MIN((uv - Vector2(1.0, 0.5)).length(), (uv - Vector2(0.5, 1.0)).length())) - w) / w, 0.0, 1.0)); + return c.linear_interpolate(a.linear_interpolate(b, coef_ab), coef_abc); } - - Color MakeTileable::_get_value_for(const Vector2 &uv, const int pseed) { - //make_tileable_$(name)($uv, 0.5*$w); - return make_tileable(uv, 0.5 * width); +MMMakeTileable::MMMakeTileable() { + width = 0.1; + size = 0; } - - float MakeTileable::get_width() { - return width; +MMMakeTileable::~MMMakeTileable() { } +void MMMakeTileable::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMMakeTileable::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMMakeTileable::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_image", "get_image"); - void MakeTileable::set_width(const float val) { - width = val; - set_dirty(true); + ClassDB::bind_method(D_METHOD("get_input"), &MMMakeTileable::get_input); + ClassDB::bind_method(D_METHOD("set_input", "value"), &MMMakeTileable::set_input); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input", "get_input"); + + ClassDB::bind_method(D_METHOD("get_width"), &MMMakeTileable::get_width); + ClassDB::bind_method(D_METHOD("set_width", "value"), &MMMakeTileable::set_width); + ADD_PROPERTY(PropertyInfo(Variant::REAL, "width"), "set_width", "get_width"); + + ClassDB::bind_method(D_METHOD("get_size"), &MMMakeTileable::get_size); + ClassDB::bind_method(D_METHOD("set_size", "value"), &MMMakeTileable::set_size); + ADD_PROPERTY(PropertyInfo(Variant::INT, "size"), "set_size", "get_size"); + + ClassDB::bind_method(D_METHOD("make_tileable", "uv", "w"), &MMMakeTileable::make_tileable); } - - //----------------------; - //make_tileable.mmg; - //vec4 make_tileable_$(name)(vec2 uv, float w) {; - // vec4 a = $in(uv); - // vec4 b = $in(fract(uv+vec2(0.5))); - // float coef_ab = sin(1.57079632679*clamp((length(uv-vec2(0.5))-0.5+w)/w, 0.0, 1.0)); - // vec4 c = $in(fract(uv+vec2(0.25))); - // float coef_abc = sin(1.57079632679*clamp((min(min(length(uv-vec2(0.0, 0.5)), length(uv-vec2(0.5, 0.0))), min(length(uv-vec2(1.0, 0.5)), length(uv-vec2(0.5, 1.0))))-w)/w, 0.0, 1.0)); - // return mix(c, mix(a, b, coef_ab), coef_abc); - //}; - - Color MakeTileable::make_tileable(const Vector2 &uv, const float w) { - Color a = input.get_value(uv); - Color b = input.get_value(MMAlgos.fractv2(uv + Vector2(0.5, 0.5))); - float coef_ab = sin(1.57079632679 * clamp(((uv - Vector2(0.5, 0.5)).length() - 0.5 + w) / w, 0.0, 1.0)); - Color c = input.get_value(MMAlgos.fractv2(uv + Vector2(0.25, 0.25))); - float coef_abc = sin(1.57079632679 * clamp((min(min((uv - Vector2(0.0, 0.5)).length(), (uv - Vector2(0.5, 0.0)).length()), min((uv- Vector2(1.0, 0.5)).length(), (uv - Vector2(0.5, 1.0)).length())) - w) / w, 0.0, 1.0)); - return lerp(c, lerp(a, b, coef_ab), coef_abc); -} - -} - - MakeTileable::MakeTileable() { - image; - input; - width = 0.1; - size = 0; - } - - MakeTileable::~MakeTileable() { - } - - - static void MakeTileable::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &MakeTileable::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &MakeTileable::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input"), &MakeTileable::get_input); - ClassDB::bind_method(D_METHOD("set_input", "value"), &MakeTileable::set_input); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - - - ClassDB::bind_method(D_METHOD("get_width"), &MakeTileable::get_width); - ClassDB::bind_method(D_METHOD("set_width", "value"), &MakeTileable::set_width); - ADD_PROPERTY(PropertyInfo(Variant::REAL, "width"), "set_width", "get_width"); - - - ClassDB::bind_method(D_METHOD("get_size"), &MakeTileable::get_size); - ClassDB::bind_method(D_METHOD("set_size", "value"), &MakeTileable::set_size); - ADD_PROPERTY(PropertyInfo(Variant::INT, "size"), "set_size", "get_size"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &MakeTileable::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &MakeTileable::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &MakeTileable::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &MakeTileable::_get_value_for); - ClassDB::bind_method(D_METHOD("get_width"), &MakeTileable::get_width); - ClassDB::bind_method(D_METHOD("set_width", "val"), &MakeTileable::set_width); - ClassDB::bind_method(D_METHOD("make_tileable", "uv", "w"), &MakeTileable::make_tileable); - - } - - - diff --git a/modules/material_maker/nodes/filter/make_tileable.h b/modules/material_maker/nodes/filter/make_tileable.h index 7b6e29125..8d3e00b57 100644 --- a/modules/material_maker/nodes/filter/make_tileable.h +++ b/modules/material_maker/nodes/filter/make_tileable.h @@ -1,57 +1,42 @@ -#ifndef MAKE_TILEABLE_H -#define MAKE_TILEABLE_H +#ifndef MM_MAKE_TILEABLE_H +#define MM_MAKE_TILEABLE_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class MakeTileable : public MMNode { - GDCLASS(MakeTileable, MMNode); +class MMMakeTileable : public MMNode { + GDCLASS(MMMakeTileable, MMNode); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input(); + void set_input(const Ref &val); - Ref get_input(); - void set_input(const Ref &val); + float get_width() const; + void set_width(const float val); - float get_width() const; - void set_width(const float val); + int get_size() const; + void set_size(const int val); - int get_size() const; - void set_size(const int val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); - float get_width(); - void set_width(const float val); - Color make_tileable(const Vector2 &uv, const float w); + Color make_tileable(const Vector2 &uv, const float w); - MakeTileable(); - ~MakeTileable(); + MMMakeTileable(); + ~MMMakeTileable(); - protected: - static void _bind_methods(); +protected: + static void _bind_methods(); - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref input; - //export(float) - float width = 0.1; - int size = 0; - //---------------------- - //make_tileable.mmg - //vec4 make_tileable_$(name)(vec2 uv, float w) { - // vec4 a = $in(uv); - // vec4 b = $in(fract(uv+vec2(0.5))); - // float coef_ab = sin(1.57079632679*clamp((length(uv-vec2(0.5))-0.5+w)/w, 0.0, 1.0)); - // vec4 c = $in(fract(uv+vec2(0.25))); - // float coef_abc = sin(1.57079632679*clamp((min(min(length(uv-vec2(0.0, 0.5)), length(uv-vec2(0.5, 0.0))), min(length(uv-vec2(1.0, 0.5)), length(uv-vec2(0.5, 1.0))))-w)/w, 0.0, 1.0)); - // return mix(c, mix(a, b, coef_ab), coef_abc); - //} + Ref image; + Ref input; + float width; + int size; }; - #endif diff --git a/modules/material_maker/nodes/filter/math.cpp b/modules/material_maker/nodes/filter/math.cpp index f802da556..120c209ba 100644 --- a/modules/material_maker/nodes/filter/math.cpp +++ b/modules/material_maker/nodes/filter/math.cpp @@ -1,369 +1,281 @@ #include "math.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref Math::get_image() { - return image; +Ref MMMath::get_image() { + return image; } -void Math::set_image(const Ref &val) { -image = val; +void MMMath::set_image(const Ref &val) { + image = val; } - -Ref Math::get_a() { - return a; +Ref MMMath::get_a() { + return a; } -void Math::set_a(const Ref &val) { -a = val; +void MMMath::set_a(const Ref &val) { + a = val; } - -Ref Math::get_b() { - return b; +Ref MMMath::get_b() { + return b; } -void Math::set_b(const Ref &val) { -b = val; +void MMMath::set_b(const Ref &val) { + b = val; } - -Ref Math::get_output() { - return output; +Ref MMMath::get_output() { + return output; } -void Math::set_output(const Ref &val) { -output = val; +void MMMath::set_output(const Ref &val) { + output = val; } - -int Math::get_operation() const { - return operation; +int MMMath::get_operation() const { + return operation; } -void Math::set_operation(const int val) { -operation = val; +void MMMath::set_operation(const int val) { + operation = val; + set_dirty(true); + output->do_emit_changed(); } - -bool Math::get_clamp_result() const { - return clamp_result; +bool MMMath::get_clamp_result() const { + return clamp_result; } -void Math::set_clamp_result(const bool val) { -clamp_result = val; +void MMMath::set_clamp_result(const bool val) { + clamp_result = val; + set_dirty(true); + output->do_emit_changed(); } +void MMMath::_init_properties() { + if (!a.is_valid()) { + a.instance(); + a->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_FLOAT); + a->set_default_value(0); + } + a->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + a->set_slot_name(">>> A "); + a->set_value_step(0.01); + a->set_value_range(Vector2(0, 1)); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref a; - //export(Resource) ; - Ref b; - //export(Resource) ; - Ref output; - //export(int, "A+B,A-B,A*B,A/B,log(A),log2(A),pow(A; B),abs(A),round(A),floor(A),ceil(A),trunc(A),fract(A),min(A; B),max(A; B),Aset_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_FLOAT); + b->set_default_value(0); + } - void Math::_init_properties() { + b->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + b->set_slot_name(">>> B "); + b->set_value_step(0.01); + b->set_value_range(Vector2(0, 1)); - if (!a) { - a = MMNodeUniversalProperty.new(); - a.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_FLOAT; - a.set_default_value(0); + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } + + //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); + //image.force_override = true; + + if (!output.is_valid()) { + output.instance(); + output->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_FLOAT); + output->set_default_value(0); + } + + output->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + output->set_slot_name(" Output >>>"); + output->set_get_value_from_owner(true); + + register_input_property(a); + register_input_property(b); + register_output_property(output); + register_output_property(image); } - a.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - a.slot_name = ">>> A "; - a.value_step = 0.01; - a.value_range = Vector2(0, 1); +void MMMath::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_label_universal(a); + mm_graph_node->add_slot_label_universal(b); + mm_graph_node->add_slot_label_universal(output); + mm_graph_node->add_slot_texture_universal(image); - if (!b) { - b = MMNodeUniversalProperty.new(); - b.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_FLOAT; - b.set_default_value(0); + Array arr; + arr.push_back("A+B"); + arr.push_back("A-B"); + arr.push_back("A*B"); + arr.push_back("A/B"); + arr.push_back("log(A)"); + arr.push_back("log2(A)"); + arr.push_back("pow(A, B)"); + arr.push_back("abs(A)"); + arr.push_back("round(A)"); + arr.push_back("floor(A)"); + arr.push_back("ceil(A)"); + arr.push_back("trunc(A)"); + arr.push_back("fract(A)"); + arr.push_back("min(A, B)"); + arr.push_back("max(A, B)"); + arr.push_back("Aadd_slot_enum("get_operation", "set_operation", "Operation", arr); + mm_graph_node->add_slot_bool("get_clamp_result", "set_clamp_result", "Clamp result"); } - b.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - b.slot_name = ">>> B "; - b.value_step = 0.01; - b.value_range = Vector2(0, 1); +Variant MMMath::_get_property_value(const Vector2 &uv) { + float af = a->get_value(uv); + float bf = b->get_value(uv); + float f = 0; + //"A+B",; - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; + if (operation == 0) { + f = af + bf; + } + //"A-B",; + else if (operation == 1) { + f = af - bf; + } + //"A*B",; + else if (operation == 2) { + f = af * bf; + } + //"A/B",; + else if (operation == 3) { + if (bf == 0) { + bf = 0.000001; + } + + f = af / bf; + } + //"log(A)",; + else if (operation == 4) { + //todo needs to be implemented; + f = log(af); + } + //"log2(A)",; + else if (operation == 5) { + //todo needs to be implemented; + f = log(af); + } + //"pow(A, B)",; + else if (operation == 6) { + f = pow(af, bf); + } + //"abs(A)",; + else if (operation == 7) { + f = abs(af); + } + //"round(A)",; + else if (operation == 8) { + f = round(af); + } + //"floor(A)",; + else if (operation == 9) { + f = floor(af); + } + //"ceil(A)",; + else if (operation == 10) { + f = ceil(af); + } + //"trunc(A)",; + else if (operation == 11) { + f = int(af); + } + //"fract(A)",; + else if (operation == 12) { + f = MMAlgos::fractf(af); + } + //"min(A, B)",; + else if (operation == 13) { + f = MIN(af, bf); + } + //"max(A, B)",; + else if (operation == 14) { + f = MAX(af, bf); + } + //"A &material) { + Ref img = render_image(material); + image->set_value(img); } - output.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - output.slot_name = " Output >>>"; - output.get_value_from_owner = true; - register_input_property(a); - register_input_property(b); - register_output_property(output); - register_output_property(image); +Color MMMath::_get_value_for(const Vector2 &uv, const int pseed) { + float f = get_property_value(uv); + return Color(f, f, f, 1); } - - void Math::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_label_universal(a); - mm_graph_node.add_slot_label_universal(b); - mm_graph_node.add_slot_label_universal(output); - mm_graph_node.add_slot_texture_universal(image); - mm_graph_node.add_slot_enum("get_operation", "set_operation", "Operation", [ "A+B", "A-B", "A*B", "A/B", "log(A)", "log2(A)", "pow(A, B)", "abs(A)", "round(A)", "floor(A)", "ceil(A)", "trunc(A)", "fract(A)", "min(A, B)", "max(A, B)", "A img = render_image(material); - image.set_value(img); -} - - - Color Math::_get_value_for(const Vector2 &uv, const int pseed) { - float f = get_property_value(uv); - return Color(f, f, f, 1); -} - - //operation; - - int Math::get_operation() { - return operation; -} - - - void Math::set_operation(const int val) { - operation = val; - set_dirty(true); - output.emit_changed(); -} - - //clamp_result; - - bool Math::get_clamp_result() { - return clamp_result; -} - - - void Math::set_clamp_result(const bool val) { - clamp_result = val; - set_dirty(true); - output.emit_changed(); -} - -} - - Math::Math() { - image; - a; - b; - output; - operation = 0; - clamp_result = false; - } - - Math::~Math() { - } - - - static void Math::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &Math::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &Math::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_a"), &Math::get_a); - ClassDB::bind_method(D_METHOD("set_a", "value"), &Math::set_a); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "a", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_a", "get_a"); - - - ClassDB::bind_method(D_METHOD("get_b"), &Math::get_b); - ClassDB::bind_method(D_METHOD("set_b", "value"), &Math::set_b); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "b", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_b", "get_b"); - - - ClassDB::bind_method(D_METHOD("get_output"), &Math::get_output); - ClassDB::bind_method(D_METHOD("set_output", "value"), &Math::set_output); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "output", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_output", "get_output"); - - - ClassDB::bind_method(D_METHOD("get_operation"), &Math::get_operation); - ClassDB::bind_method(D_METHOD("set_operation", "value"), &Math::set_operation); - ADD_PROPERTY(PropertyInfo(Variant::INT, "operation"), "set_operation", "get_operation"); - - - ClassDB::bind_method(D_METHOD("get_clamp_result"), &Math::get_clamp_result); - ClassDB::bind_method(D_METHOD("set_clamp_result", "value"), &Math::set_clamp_result); - ADD_PROPERTY(PropertyInfo(Variant::BOOL, "clamp_result"), "set_clamp_result", "get_clamp_result"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &Math::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &Math::_register_methods); - ClassDB::bind_method(D_METHOD("_get_property_value", "uv"), &Math::_get_property_value); - ClassDB::bind_method(D_METHOD("_render", "material"), &Math::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &Math::_get_value_for); - ClassDB::bind_method(D_METHOD("get_operation"), &Math::get_operation); - ClassDB::bind_method(D_METHOD("set_operation", "val"), &Math::set_operation); - ClassDB::bind_method(D_METHOD("get_clamp_result"), &Math::get_clamp_result); - ClassDB::bind_method(D_METHOD("set_clamp_result", "val"), &Math::set_clamp_result); - - } - - - diff --git a/modules/material_maker/nodes/filter/math.h b/modules/material_maker/nodes/filter/math.h index 6ed4208e5..d48ae5456 100644 --- a/modules/material_maker/nodes/filter/math.h +++ b/modules/material_maker/nodes/filter/math.h @@ -1,62 +1,50 @@ -#ifndef MATH_H -#define MATH_H +#ifndef MM_MATH_H +#define MM_MATH_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class Math : public MMNode { - GDCLASS(Math, MMNode); +class MMMath : public MMNode { + GDCLASS(MMMath, MMNode); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_a(); + void set_a(const Ref &val); - Ref get_a(); - void set_a(const Ref &val); + Ref get_b(); + void set_b(const Ref &val); - Ref get_b(); - void set_b(const Ref &val); + Ref get_output(); + void set_output(const Ref &val); - Ref get_output(); - void set_output(const Ref &val); + int get_operation() const; + void set_operation(const int val); - int get_operation() const; - void set_operation(const int val); + bool get_clamp_result() const; + void set_clamp_result(const bool val); - bool get_clamp_result() const; - void set_clamp_result(const bool val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + Variant _get_property_value(const Vector2 &uv); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - float _get_property_value(const Vector2 &uv); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); - int get_operation(); - void set_operation(const int val); - bool get_clamp_result(); - void set_clamp_result(const bool val); + MMMath(); + ~MMMath(); - Math(); - ~Math(); +protected: + static void _bind_methods(); - protected: - static void _bind_methods(); - - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref a; - //export(Resource) - Ref b; - //export(Resource) - Ref output; - //export(int, "A+B,A-B,A*B,A/B,log(A),log2(A),pow(A; B),abs(A),round(A),floor(A),ceil(A),trunc(A),fract(A),min(A; B),max(A; B),A image; + Ref a; + Ref b; + Ref output; + //export(int, "A+B,A-B,A*B,A/B,log(A),log2(A),pow(A; B),abs(A),round(A),floor(A),ceil(A),trunc(A),fract(A),min(A; B),max(A; B),A Quantize::get_image() { - return image; +Ref MMQuantize::get_image() { + return image; } -void Quantize::set_image(const Ref &val) { -image = val; +void MMQuantize::set_image(const Ref &val) { + image = val; } - -Ref Quantize::get_input() { - return input; +Ref MMQuantize::get_input() { + return input; } -void Quantize::set_input(const Ref &val) { -input = val; +void MMQuantize::set_input(const Ref &val) { + input = val; } - -int Quantize::get_steps() const { - return steps; +int MMQuantize::get_steps() const { + return steps; } -void Quantize::set_steps(const int val) { -steps = val; +void MMQuantize::set_steps(const int val) { + steps = val; + set_dirty(true); } +void MMQuantize::_init_properties() { + if (!input.is_valid()) { + input.instance(); + input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR); + input->set_default_value(Color(0, 0, 0, 1)); + } + input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input->set_slot_name(">>> Input "); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input; - //export(int) ; - int steps = 4; + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } - void Quantize::_init_properties() { - - if (!input) { - input = MMNodeUniversalProperty.new(); - input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; - input.set_default_value(Color(0, 0, 0, 1)); + //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); + //image.force_override = true; + register_input_property(input); + register_output_property(image); } - input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input.slot_name = ">>> Input "; - - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; +void MMQuantize::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_label_universal(input); + mm_graph_node->add_slot_texture_universal(image); + mm_graph_node->add_slot_int("get_steps", "set_steps", "Steps"); } - //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - //image.force_override = true; - register_input_property(input); - register_output_property(image); +void MMQuantize::_render(const Ref &material) { + Ref img = render_image(material); + image->set_value(img); } - - void Quantize::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_label_universal(input); - mm_graph_node.add_slot_texture_universal(image); - mm_graph_node.add_slot_int("get_steps", "set_steps", "Steps"); +Color MMQuantize::_get_value_for(const Vector2 &uv, const int pseed) { + Color c = input->get_value(uv); + //vec4(floor($in($uv).rgb*$steps)/$steps, $in($uv).a); + Vector3 v = MMAlgos::floorv3(Vector3(c.r, c.g, c.b) * steps) / float(steps); + return Color(v.x, v.y, v.z, c.a); } - - void Quantize::_render(const Variant &material) { - Ref img = render_image(material); - image.set_value(img); +MMQuantize::MMQuantize() { + steps = 4; } - - Color Quantize::_get_value_for(const Vector2 &uv, const int pseed) { - Color c = input.get_value(uv); - //vec4(floor($in($uv).rgb*$steps)/$steps, $in($uv).a); - Vector3 v = MMAlgos.floorv3(Vector3(c.r, c.g, c.b) * steps) / float(steps); - return Color(v.x, v.y, v.z, c.a); +MMQuantize::~MMQuantize() { } - //steps; +void MMQuantize::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMQuantize::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMQuantize::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_image", "get_image"); - int Quantize::get_steps() { - return steps; + ClassDB::bind_method(D_METHOD("get_input"), &MMQuantize::get_input); + ClassDB::bind_method(D_METHOD("set_input", "value"), &MMQuantize::set_input); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input", "get_input"); + + ClassDB::bind_method(D_METHOD("get_steps"), &MMQuantize::get_steps); + ClassDB::bind_method(D_METHOD("set_steps", "value"), &MMQuantize::set_steps); + ADD_PROPERTY(PropertyInfo(Variant::INT, "steps"), "set_steps", "get_steps"); } - - - void Quantize::set_steps(const int val) { - steps = val; - set_dirty(true); -} - -} - - Quantize::Quantize() { - image; - input; - steps = 4; - } - - Quantize::~Quantize() { - } - - - static void Quantize::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &Quantize::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &Quantize::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input"), &Quantize::get_input); - ClassDB::bind_method(D_METHOD("set_input", "value"), &Quantize::set_input); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - - - ClassDB::bind_method(D_METHOD("get_steps"), &Quantize::get_steps); - ClassDB::bind_method(D_METHOD("set_steps", "value"), &Quantize::set_steps); - ADD_PROPERTY(PropertyInfo(Variant::INT, "steps"), "set_steps", "get_steps"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &Quantize::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &Quantize::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &Quantize::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &Quantize::_get_value_for); - ClassDB::bind_method(D_METHOD("get_steps"), &Quantize::get_steps); - ClassDB::bind_method(D_METHOD("set_steps", "val"), &Quantize::set_steps); - - } - - - diff --git a/modules/material_maker/nodes/filter/quantize.h b/modules/material_maker/nodes/filter/quantize.h index c9028c4d2..42065025c 100644 --- a/modules/material_maker/nodes/filter/quantize.h +++ b/modules/material_maker/nodes/filter/quantize.h @@ -1,43 +1,36 @@ -#ifndef QUANTIZE_H -#define QUANTIZE_H +#ifndef MM_QUANTIZE_H +#define MM_QUANTIZE_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class Quantize : public MMNode { - GDCLASS(Quantize, MMNode); +class MMQuantize : public MMNode { + GDCLASS(MMQuantize, MMNode); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input(); + void set_input(const Ref &val); - Ref get_input(); - void set_input(const Ref &val); + int get_steps() const; + void set_steps(const int val); - int get_steps() const; - void set_steps(const int val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); - int get_steps(); - void set_steps(const int val); + MMQuantize(); + ~MMQuantize(); - Quantize(); - ~Quantize(); +protected: + static void _bind_methods(); - protected: - static void _bind_methods(); - - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref input; - //export(int) - int steps = 4; - //steps + Ref image; + Ref input; + int steps; }; - #endif diff --git a/modules/material_maker/nodes/filter/swap_channels.cpp b/modules/material_maker/nodes/filter/swap_channels.cpp index 5ba97e5c8..ae06abef9 100644 --- a/modules/material_maker/nodes/filter/swap_channels.cpp +++ b/modules/material_maker/nodes/filter/swap_channels.cpp @@ -1,285 +1,176 @@ #include "swap_channels.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref SwapChannels::get_image() { - return image; +Ref MMSwapChannels::get_image() { + return image; } -void SwapChannels::set_image(const Ref &val) { -image = val; +void MMSwapChannels::set_image(const Ref &val) { + image = val; } - -Ref SwapChannels::get_input() { - return input; +Ref MMSwapChannels::get_input() { + return input; } -void SwapChannels::set_input(const Ref &val) { -input = val; +void MMSwapChannels::set_input(const Ref &val) { + input = val; } - -int SwapChannels::get_op_r() const { - return op_r; +int MMSwapChannels::get_op_r() const { + return op_r; } -void SwapChannels::set_op_r(const int val) { -op_r = val; +void MMSwapChannels::set_op_r(const int val) { + op_r = val; + set_dirty(true); } - -int SwapChannels::get_op_g() const { - return op_g; +int MMSwapChannels::get_op_g() const { + return op_g; } -void SwapChannels::set_op_g(const int val) { -op_g = val; +void MMSwapChannels::set_op_g(const int val) { + op_g = val; + set_dirty(true); } - -int SwapChannels::get_op_b() const { - return op_b; +int MMSwapChannels::get_op_b() const { + return op_b; } -void SwapChannels::set_op_b(const int val) { -op_b = val; +void MMSwapChannels::set_op_b(const int val) { + op_b = val; + set_dirty(true); } - -int SwapChannels::get_op_a() const { - return op_a; +int MMSwapChannels::get_op_a() const { + return op_a; } -void SwapChannels::set_op_a(const int val) { -op_a = val; +void MMSwapChannels::set_op_a(const int val) { + op_a = val; + set_dirty(true); } +void MMSwapChannels::_init_properties() { + if (!input.is_valid()) { + input.instance(); + input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR); + input->set_default_value(Color(0, 0, 0, 1)); + } + input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input->set_slot_name(">>> Input "); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input; - //export(int, "0,1,R,-R,G,-G,B,-B,A,-A") ; - int op_r = 2; - //export(int, "0,1,R,-R,G,-G,B,-B,A,-A") ; - int op_g = 4; - //export(int, "0,1,R,-R,G,-G,B,-B,A,-A") ; - int op_b = 6; - //export(int, "0,1,R,-R,G,-G,B,-B,A,-A") ; - int op_a = 8; + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } - void SwapChannels::_init_properties() { - - if (!input) { - input = MMNodeUniversalProperty.new(); - input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; - input.set_default_value(Color(0, 0, 0, 1)); + //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); + //image.force_override = true; + register_input_property(input); + register_output_property(image); } - input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input.slot_name = ">>> Input "; +void MMSwapChannels::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_label_universal(input); + mm_graph_node->add_slot_texture_universal(image); - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; + Array arr; + arr.push_back("0"); + arr.push_back("1"); + arr.push_back("R"); + arr.push_back("-R"); + arr.push_back("G"); + arr.push_back("-G"); + arr.push_back("B"); + arr.push_back("-B"); + arr.push_back("A"); + arr.push_back("-A"); + + mm_graph_node->add_slot_enum("get_op_r", "set_op_r", "R", arr); + mm_graph_node->add_slot_enum("get_op_g", "set_op_g", "G", arr); + mm_graph_node->add_slot_enum("get_op_b", "set_op_b", "B", arr); + mm_graph_node->add_slot_enum("get_op_a", "set_op_a", "A", arr); } - //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - //image.force_override = true; - register_input_property(input); - register_output_property(image); +void MMSwapChannels::_render(const Ref &material) { + Ref img = render_image(material); + image->set_value(img); } +float MMSwapChannels::apply(const int op, const Color &val) { + if (op == 0) { + return 0.0; + } else if (op == 1) { + return 1.0; + } else if (op == 2) { + return val.r; + } else if (op == 3) { + return 1.0 - val.r; + } else if (op == 4) { + return val.g; + } else if (op == 5) { + return 1.0 - val.g; + } else if (op == 6) { + return val.b; + } else if (op == 7) { + return 1.0 - val.b; + } else if (op == 8) { + return val.a; + } else if (op == 9) { + return 1.0 - val.a; + } - void SwapChannels::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_label_universal(input); - mm_graph_node.add_slot_texture_universal(image); - mm_graph_node.add_slot_enum("get_op_r", "set_op_r", "R", [ "0", "1", "R", "-R", "G", "-G", "B", "-B", "A","-A" ]); - mm_graph_node.add_slot_enum("get_op_g", "set_op_g", "G", [ "0", "1", "R", "-R", "G", "-G", "B", "-B", "A","-A" ]); - mm_graph_node.add_slot_enum("get_op_b", "set_op_b", "B", [ "0", "1", "R", "-R", "G", "-G", "B", "-B", "A","-A" ]); - mm_graph_node.add_slot_enum("get_op_a", "set_op_a", "A", [ "0", "1", "R", "-R", "G", "-G", "B", "-B", "A","-A" ]); + return 0.0; } - - void SwapChannels::_render(const Variant &material) { - Ref img = render_image(material); - image.set_value(img); +Color MMSwapChannels::_get_value_for(const Vector2 &uv, const int pseed) { + Color c = input->get_value(uv); + return Color(apply(op_r, c), apply(op_g, c), apply(op_b, c), apply(op_a, c)); } - - float SwapChannels::apply(const int op, const Color &val) { - - if (op == 0) { - return 0.0; +MMSwapChannels::MMSwapChannels() { + op_r = 2; + op_g = 4; + op_b = 6; + op_a = 8; } - - else if (op == 1) { - return 1.0; +MMSwapChannels::~MMSwapChannels() { } +void MMSwapChannels::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMSwapChannels::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMSwapChannels::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_image", "get_image"); - else if (op == 2) { - return val.r; + ClassDB::bind_method(D_METHOD("get_input"), &MMSwapChannels::get_input); + ClassDB::bind_method(D_METHOD("set_input", "value"), &MMSwapChannels::set_input); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input", "get_input"); + + ClassDB::bind_method(D_METHOD("get_op_r"), &MMSwapChannels::get_op_r); + ClassDB::bind_method(D_METHOD("set_op_r", "value"), &MMSwapChannels::set_op_r); + ADD_PROPERTY(PropertyInfo(Variant::INT, "op_r"), "set_op_r", "get_op_r"); + + ClassDB::bind_method(D_METHOD("get_op_g"), &MMSwapChannels::get_op_g); + ClassDB::bind_method(D_METHOD("set_op_g", "value"), &MMSwapChannels::set_op_g); + ADD_PROPERTY(PropertyInfo(Variant::INT, "op_g"), "set_op_g", "get_op_g"); + + ClassDB::bind_method(D_METHOD("get_op_b"), &MMSwapChannels::get_op_b); + ClassDB::bind_method(D_METHOD("set_op_b", "value"), &MMSwapChannels::set_op_b); + ADD_PROPERTY(PropertyInfo(Variant::INT, "op_b"), "set_op_b", "get_op_b"); + + ClassDB::bind_method(D_METHOD("get_op_a"), &MMSwapChannels::get_op_a); + ClassDB::bind_method(D_METHOD("set_op_a", "value"), &MMSwapChannels::set_op_a); + ADD_PROPERTY(PropertyInfo(Variant::INT, "op_a"), "set_op_a", "get_op_a"); + + ClassDB::bind_method(D_METHOD("apply", "op", "val"), &MMSwapChannels::apply); } - - - else if (op == 3) { - return 1.0 - val.r; -} - - - else if (op == 4) { - return val.g; -} - - - else if (op == 5) { - return 1.0 - val.g; -} - - - else if (op == 6) { - return val.b; -} - - - else if (op == 7) { - return 1.0 - val.b; -} - - - else if (op == 8) { - return val.a; -} - - - else if (op == 9) { - return 1.0 - val.a; -} - - return 0.0; -} - - - Color SwapChannels::_get_value_for(const Vector2 &uv, const int pseed) { - Color c = input.get_value(uv); - return Color(apply(op_r, c), apply(op_g, c), apply(op_b, c), apply(op_a, c)); -} - - //op_r; - - int SwapChannels::get_op_r() { - return op_r; -} - - - void SwapChannels::set_op_r(const int val) { - op_r = val; - set_dirty(true); -} - - //op_g; - - int SwapChannels::get_op_g() { - return op_g; -} - - - void SwapChannels::set_op_g(const int val) { - op_g = val; - set_dirty(true); -} - - //op_b; - - int SwapChannels::get_op_b() { - return op_b; -} - - - void SwapChannels::set_op_b(const int val) { - op_b = val; - set_dirty(true); -} - - //op_a; - - int SwapChannels::get_op_a() { - return op_a; -} - - - void SwapChannels::set_op_a(const int val) { - op_a = val; - set_dirty(true); -} - -} - - SwapChannels::SwapChannels() { - image; - input; - op_r = 2; - op_g = 4; - op_b = 6; - op_a = 8; - } - - SwapChannels::~SwapChannels() { - } - - - static void SwapChannels::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &SwapChannels::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &SwapChannels::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input"), &SwapChannels::get_input); - ClassDB::bind_method(D_METHOD("set_input", "value"), &SwapChannels::set_input); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - - - ClassDB::bind_method(D_METHOD("get_op_r"), &SwapChannels::get_op_r); - ClassDB::bind_method(D_METHOD("set_op_r", "value"), &SwapChannels::set_op_r); - ADD_PROPERTY(PropertyInfo(Variant::INT, "op_r"), "set_op_r", "get_op_r"); - - - ClassDB::bind_method(D_METHOD("get_op_g"), &SwapChannels::get_op_g); - ClassDB::bind_method(D_METHOD("set_op_g", "value"), &SwapChannels::set_op_g); - ADD_PROPERTY(PropertyInfo(Variant::INT, "op_g"), "set_op_g", "get_op_g"); - - - ClassDB::bind_method(D_METHOD("get_op_b"), &SwapChannels::get_op_b); - ClassDB::bind_method(D_METHOD("set_op_b", "value"), &SwapChannels::set_op_b); - ADD_PROPERTY(PropertyInfo(Variant::INT, "op_b"), "set_op_b", "get_op_b"); - - - ClassDB::bind_method(D_METHOD("get_op_a"), &SwapChannels::get_op_a); - ClassDB::bind_method(D_METHOD("set_op_a", "value"), &SwapChannels::set_op_a); - ADD_PROPERTY(PropertyInfo(Variant::INT, "op_a"), "set_op_a", "get_op_a"); - - - ClassDB::bind_method(D_METHOD("_init_properties"), &SwapChannels::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &SwapChannels::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &SwapChannels::_render); - ClassDB::bind_method(D_METHOD("apply", "op", "val"), &SwapChannels::apply); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &SwapChannels::_get_value_for); - ClassDB::bind_method(D_METHOD("get_op_r"), &SwapChannels::get_op_r); - ClassDB::bind_method(D_METHOD("set_op_r", "val"), &SwapChannels::set_op_r); - ClassDB::bind_method(D_METHOD("get_op_g"), &SwapChannels::get_op_g); - ClassDB::bind_method(D_METHOD("set_op_g", "val"), &SwapChannels::set_op_g); - ClassDB::bind_method(D_METHOD("get_op_b"), &SwapChannels::get_op_b); - ClassDB::bind_method(D_METHOD("set_op_b", "val"), &SwapChannels::set_op_b); - ClassDB::bind_method(D_METHOD("get_op_a"), &SwapChannels::get_op_a); - ClassDB::bind_method(D_METHOD("set_op_a", "val"), &SwapChannels::set_op_a); - - } - - - diff --git a/modules/material_maker/nodes/filter/swap_channels.h b/modules/material_maker/nodes/filter/swap_channels.h index 617798e2b..59d5a8efc 100644 --- a/modules/material_maker/nodes/filter/swap_channels.h +++ b/modules/material_maker/nodes/filter/swap_channels.h @@ -1,68 +1,55 @@ -#ifndef SWAP_CHANNELS_H -#define SWAP_CHANNELS_H +#ifndef MM_SWAP_CHANNELS_H +#define MM_SWAP_CHANNELS_H +#include "../mm_node.h" +#include "../mm_node_universal_property.h" -class SwapChannels : public MMNode { - GDCLASS(SwapChannels, MMNode); +class MMSwapChannels : public MMNode { + GDCLASS(MMSwapChannels, MMNode); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input(); + void set_input(const Ref &val); - Ref get_input(); - void set_input(const Ref &val); + int get_op_r() const; + void set_op_r(const int val); - int get_op_r() const; - void set_op_r(const int val); + int get_op_g() const; + void set_op_g(const int val); - int get_op_g() const; - void set_op_g(const int val); + int get_op_b() const; + void set_op_b(const int val); - int get_op_b() const; - void set_op_b(const int val); + int get_op_a() const; + void set_op_a(const int val); - int get_op_a() const; - void set_op_a(const int val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - float apply(const int op, const Color &val); - Color _get_value_for(const Vector2 &uv, const int pseed); - int get_op_r(); - void set_op_r(const int val); - int get_op_g(); - void set_op_g(const int val); - int get_op_b(); - void set_op_b(const int val); - int get_op_a(); - void set_op_a(const int val); + float apply(const int op, const Color &val); - SwapChannels(); - ~SwapChannels(); + Color _get_value_for(const Vector2 &uv, const int pseed); - protected: - static void _bind_methods(); + MMSwapChannels(); + ~MMSwapChannels(); - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref input; - //export(int, "0,1,R,-R,G,-G,B,-B,A,-A") - int op_r = 2; - //export(int, "0,1,R,-R,G,-G,B,-B,A,-A") - int op_g = 4; - //export(int, "0,1,R,-R,G,-G,B,-B,A,-A") - int op_b = 6; - //export(int, "0,1,R,-R,G,-G,B,-B,A,-A") - int op_a = 8; - //op_r - //op_g - //op_b - //op_a +protected: + static void _bind_methods(); + + Ref image; + Ref input; + //export(int, "0,1,R,-R,G,-G,B,-B,A,-A") + int op_r; + //export(int, "0,1,R,-R,G,-G,B,-B,A,-A") + int op_g; + //export(int, "0,1,R,-R,G,-G,B,-B,A,-A") + int op_b; + //export(int, "0,1,R,-R,G,-G,B,-B,A,-A") + int op_a; }; - #endif diff --git a/modules/material_maker/nodes/filter/tonality.cpp b/modules/material_maker/nodes/filter/tonality.cpp index feb5a50f1..3b687993f 100644 --- a/modules/material_maker/nodes/filter/tonality.cpp +++ b/modules/material_maker/nodes/filter/tonality.cpp @@ -1,115 +1,89 @@ #include "tonality.h" +#include "../../algos/mm_algos.h" +#include "../../editor/mm_graph_node.h" +#include "../mm_material.h" -Ref Tonality::get_image() { - return image; +Ref MMTonality::get_image() { + return image; } -void Tonality::set_image(const Ref &val) { -image = val; +void MMTonality::set_image(const Ref &val) { + image = val; } - -Ref Tonality::get_input() { - return input; +Ref MMTonality::get_input() { + return input; } -void Tonality::set_input(const Ref &val) { -input = val; +void MMTonality::set_input(const Ref &val) { + input = val; } +void MMTonality::_init_properties() { + if (!input.is_valid()) { + input.instance(); + input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_FLOAT); + input->set_default_value(0); + } + input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL); + input->set_slot_name(">>> Input "); - //tool; - //export(Resource) ; - Ref image; - //export(Resource) ; - Ref input; + if (!image.is_valid()) { + image.instance(); + image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE); + } - void Tonality::_init() { - init_points_01(); + //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; + image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE); + //image.force_override = true; + register_input_property(input); + register_output_property(image); } - - void Tonality::_init_properties() { - - if (!input) { - input = MMNodeUniversalProperty.new(); - input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_FLOAT; - input.set_default_value(0); +void MMTonality::_register_methods(MMGraphNode *mm_graph_node) { + mm_graph_node->add_slot_label_universal(input); + mm_graph_node->add_slot_texture_universal(image); + mm_graph_node->add_slot_curve(); } - input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; - input.slot_name = ">>> Input "; - - if (!image) { - image = MMNodeUniversalProperty.new(); - image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE; +void MMTonality::_render(const Ref &material) { + Ref img = render_image(material); + image->set_value(img); } - //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; - image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; - //image.force_override = true; - register_input_property(input); - register_output_property(image); +Color MMTonality::_get_value_for(const Vector2 &uv, const int pseed) { + float f = input->get_value(uv); + float cf = MMAlgos::curve(f, points); + return Color(cf, cf, cf, 1); } - - void Tonality::_register_methods(const Variant &mm_graph_node) { - mm_graph_node.add_slot_label_universal(input); - mm_graph_node.add_slot_texture_universal(image); - mm_graph_node.add_slot_curve(); +void MMTonality::_curve_changed() { + set_dirty(true); } - - void Tonality::_render(const Variant &material) { - Ref img = render_image(material); - image.set_value(img); +MMTonality::MMTonality() { } - - Color Tonality::_get_value_for(const Vector2 &uv, const int pseed) { - float f = input.get_value(uv); - float cf = MMAlgos.curve(f, points_array); - return Color(cf, cf, cf, 1); +MMTonality::~MMTonality() { } - - void Tonality::_curve_changed() { - set_dirty(true); +void MMTonality::_notification(int p_what) { + if (p_what == NOTIFICATION_POSTINITIALIZE) { + if (points.size() == 0) { + init_points_01(); + } + } } +void MMTonality::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_image"), &MMTonality::get_image); + ClassDB::bind_method(D_METHOD("set_image", "value"), &MMTonality::set_image); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_image", "get_image"); + + ClassDB::bind_method(D_METHOD("get_input"), &MMTonality::get_input); + ClassDB::bind_method(D_METHOD("set_input", "value"), &MMTonality::set_input); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input", "get_input"); } - - Tonality::Tonality() { - image; - input; - } - - Tonality::~Tonality() { - } - - - static void Tonality::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_image"), &Tonality::get_image); - ClassDB::bind_method(D_METHOD("set_image", "value"), &Tonality::set_image); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_image", "get_image"); - - - ClassDB::bind_method(D_METHOD("get_input"), &Tonality::get_input); - ClassDB::bind_method(D_METHOD("set_input", "value"), &Tonality::set_input); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref"), "set_input", "get_input"); - - - ClassDB::bind_method(D_METHOD("_init"), &Tonality::_init); - ClassDB::bind_method(D_METHOD("_init_properties"), &Tonality::_init_properties); - ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &Tonality::_register_methods); - ClassDB::bind_method(D_METHOD("_render", "material"), &Tonality::_render); - ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &Tonality::_get_value_for); - ClassDB::bind_method(D_METHOD("_curve_changed"), &Tonality::_curve_changed); - - } - - - diff --git a/modules/material_maker/nodes/filter/tonality.h b/modules/material_maker/nodes/filter/tonality.h index 8ba2757e6..a59bbc2e3 100644 --- a/modules/material_maker/nodes/filter/tonality.h +++ b/modules/material_maker/nodes/filter/tonality.h @@ -1,37 +1,35 @@ -#ifndef TONALITY_H -#define TONALITY_H +#ifndef MM_TONALITY_H +#define MM_TONALITY_H +#include "../bases/curve_base.h" +#include "../mm_node_universal_property.h" -class Tonality : public CurveBase { - GDCLASS(Tonality, CurveBase); +class MMTonality : public CurveBase { + GDCLASS(MMTonality, CurveBase); - public: +public: + Ref get_image(); + void set_image(const Ref &val); - Ref get_image(); - void set_image(const Ref &val); + Ref get_input(); + void set_input(const Ref &val); - Ref get_input(); - void set_input(const Ref &val); + void _init_properties(); + void _register_methods(MMGraphNode *mm_graph_node); + void _render(const Ref &material); + Color _get_value_for(const Vector2 &uv, const int pseed); + void _curve_changed(); - void _init(); - void _init_properties(); - void _register_methods(const Variant &mm_graph_node); - void _render(const Variant &material); - Color _get_value_for(const Vector2 &uv, const int pseed); - void _curve_changed(); + MMTonality(); + ~MMTonality(); - Tonality(); - ~Tonality(); +protected: + void _notification(int p_what); - protected: - static void _bind_methods(); + static void _bind_methods(); - //tool - //export(Resource) - Ref image; - //export(Resource) - Ref input; + Ref image; + Ref input; }; - #endif diff --git a/modules/material_maker/register_types.cpp b/modules/material_maker/register_types.cpp index 43f194930..eab49e649 100644 --- a/modules/material_maker/register_types.cpp +++ b/modules/material_maker/register_types.cpp @@ -130,6 +130,29 @@ SOFTWARE. #include "nodes/gradient/gradient.h" #include "nodes/gradient/radial_gradient.h" +#include "nodes/filter/adjust_hsv.h" +#include "nodes/filter/blend.h" +#include "nodes/filter/blur_gaussian.h" +#include "nodes/filter/brightness_contrast.h" +#include "nodes/filter/colorize.h" +#include "nodes/filter/combine.h" +#include "nodes/filter/decompose.h" +#include "nodes/filter/emboss.h" +#include "nodes/filter/fill_channel.h" +#include "nodes/filter/fill_to_color.h" +#include "nodes/filter/fill_to_position.h" +#include "nodes/filter/fill_to_random_color.h" +#include "nodes/filter/fill_to_random_grey.h" +#include "nodes/filter/fill_to_size.h" +#include "nodes/filter/fill_to_uv.h" +#include "nodes/filter/greyscale.h" +#include "nodes/filter/invert.h" +#include "nodes/filter/make_tileable.h" +#include "nodes/filter/math.h" +#include "nodes/filter/quantize.h" +#include "nodes/filter/swap_channels.h" +#include "nodes/filter/tonality.h" + static _MMAlgos *_mm_algos_singleton = nullptr; void register_material_maker_types() { @@ -303,6 +326,51 @@ void register_material_maker_types() { ClassDB::register_class(); MMAlgos::register_node_class("Gradient", "MMCircularGradient"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMTonality"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMSwapChannels"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMQuantize"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMMath"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMMakeTileable"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMInvert"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMGreyscale"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMFillToUv"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMFillToSize"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMFillToRandomGrey"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMFillToRandomColor"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMFillToPosition"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMFillToColor"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMFillChannel"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMEmboss"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMDecompose"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMCombine"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMColorize"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMBrightnessContrast"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMBlurGaussian"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMBlend"); + ClassDB::register_class(); + MMAlgos::register_node_class("Filter", "MMAdjustHsv"); + _mm_algos_singleton = memnew(_MMAlgos); Engine::get_singleton()->add_singleton(Engine::Singleton("MMAlgos", _MMAlgos::get_singleton()));