Relintai/pandemonium_engine
1
0
Fork 0
mirror of https://github.com/Relintai/pandemonium_engine.git synced 2025-04-14 23:58:26 +02:00
Code Issues Packages Projects Releases Wiki Activity

Cleaned up MMCircleMap, MMColorTiler, and the MMKaleidoscope nodes.

Browse Source
This commit is contained in:
Relintai 2022-06-17 01:14:46 +02:00
parent e1493ecac6
commit 0c759b2f16
9 changed files with 617 additions and 1025 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
modules/material_maker/SCsub
View File

@ -61,6 +61,9 @@ sources = [
"nodes/transform/rotate.cpp", "nodes/transform/rotate.cpp",
"nodes/transform/repeat.cpp", "nodes/transform/repeat.cpp",
"nodes/transform/mirror.cpp", "nodes/transform/mirror.cpp",
"nodes/transform/kaleidoscope.cpp",
"nodes/transform/color_tiler.cpp",
"nodes/transform/circle_map.cpp",
] ]
if env["tools"]: if env["tools"]:

2
modules/material_maker/config.py
View File

@ -31,6 +31,8 @@ def get_doc_classes():
"MMRotate", "MMRotate",
"MMRepeat", "MMRepeat",
"MMMirror", "MMMirror",
"MMKaleidoscope",
"MMColorTiler",
] ]
def get_doc_path(): def get_doc_path():

207
modules/material_maker/nodes/transform/circle_map.cpp
View File

@ -1,171 +1,112 @@
#include "circle_map.h" #include "circle_map.h"
#include "../../algos/mm_algos.h"
#include "../../editor/mm_graph_node.h"
#include "../mm_material.h"
Ref<Resource> CircleMap::get_image() { Ref<MMNodeUniversalProperty> MMCircleMap::get_image() {
return image; return image;
} }
void CircleMap::set_image(const Ref<Resource> &val) { void MMCircleMap::set_image(const Ref<MMNodeUniversalProperty> &val) {
image = val; image = val;
} }
Ref<MMNodeUniversalProperty> MMCircleMap::get_input() {
Ref<Resource> CircleMap::get_input() { return input;
return input;
} }
void CircleMap::set_input(const Ref<Resource> &val) { void MMCircleMap::set_input(const Ref<MMNodeUniversalProperty> &val) {
input = val; input = val;
} }
float MMCircleMap::get_radius() const {
float CircleMap::get_radius() const { return radius;
return radius;
} }
void CircleMap::set_radius(const float val) { void MMCircleMap::set_radius(const float val) {
radius = val; radius = val;
if (radius == 0) {
radius = 0.000000001;
}
set_dirty(true);
} }
int MMCircleMap::get_repeat() const {
int CircleMap::get_repeat() const { return repeat;
return repeat;
} }
void CircleMap::set_repeat(const int val) { void MMCircleMap::set_repeat(const int val) {
repeat = val; repeat = val;
set_dirty(true);
} }
void MMCircleMap::_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; if (!image.is_valid()) {
//export(Resource) ; image.instance();
Ref<Resource> image; image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE);
//export(Resource) ; }
Ref<Resource> input;
//export(float) ;
float radius = 1;
//export(int) ;
int repeat = 1;
void CircleMap::_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) { register_input_property(input);
input = MMNodeUniversalProperty.new(); register_output_property(image);
input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR;
input.set_default_value(Color(0, 0, 0, 1));
} }
input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; void MMCircleMap::_register_methods(MMGraphNode *mm_graph_node) {
input.slot_name = ">>> Input "; mm_graph_node->add_slot_label_universal(input);
mm_graph_node->add_slot_texture_universal(image);
if (!image) { mm_graph_node->add_slot_float("get_radius", "set_radius", "Radius", 0.01);
image = MMNodeUniversalProperty.new(); mm_graph_node->add_slot_int("get_repeat", "set_repeat", "Repeat");
image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE;
} }
//image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; void MMCircleMap::_render(const Ref<MMMaterial> &material) {
image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; Ref<Image> img = render_image(material);
//image.force_override = true; image->set_value(img);
register_input_property(input);
register_output_property(image);
} }
Color MMCircleMap::_get_value_for(const Vector2 &uv, const int pseed) {
void CircleMap::_register_methods(const Variant &mm_graph_node) { //$in(vec2(fract($repeat*atan($uv.y-0.5, $uv.x-0.5)*0.15915494309), min(0.99999, 2.0/$radius*length($uv-vec2(0.5)))))",;
mm_graph_node.add_slot_label_universal(input); Vector2 nuv = Vector2(MMAlgos::fractf(repeat * Math::atan2(uv.y - 0.5, uv.x - 0.5) * 0.15915494309), MIN(0.99999, 2.0 / radius * (uv - Vector2(0.5, 0.5)).length()));
mm_graph_node.add_slot_texture_universal(image); return input->get_value(nuv);
mm_graph_node.add_slot_float("get_radius", "set_radius", "Radius", 0.01);
mm_graph_node.add_slot_int("get_repeat", "set_repeat", "Repeat");
} }
MMCircleMap::MMCircleMap() {
void CircleMap::_render(const Variant &material) { radius = 1;
Ref<Image> img = render_image(material); repeat = 1;
image.set_value(img);
} }
MMCircleMap::~MMCircleMap() {
Color CircleMap::_get_value_for(const Vector2 &uv, const int pseed) {
//$in(vec2(fract($repeat*atan($uv.y-0.5, $uv.x-0.5)*0.15915494309), min(0.99999, 2.0/$radius*length($uv-vec2(0.5)))))",;
Vector2 nuv = Vector2(MMAlgos.fractf(repeat*atan2(uv.y - 0.5, uv.x - 0.5) * 0.15915494309), min(0.99999, 2.0 / radius * (uv - Vector2(0.5, 0.5)).length()));
return input.get_value(nuv);
} }
//radius; void MMCircleMap::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_image"), &MMCircleMap::get_image);
ClassDB::bind_method(D_METHOD("set_image", "value"), &MMCircleMap::set_image);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_image", "get_image");
float CircleMap::get_radius() { ClassDB::bind_method(D_METHOD("get_input"), &MMCircleMap::get_input);
return radius; ClassDB::bind_method(D_METHOD("set_input", "value"), &MMCircleMap::set_input);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input", "get_input");
ClassDB::bind_method(D_METHOD("get_radius"), &MMCircleMap::get_radius);
ClassDB::bind_method(D_METHOD("set_radius", "value"), &MMCircleMap::set_radius);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "radius"), "set_radius", "get_radius");
ClassDB::bind_method(D_METHOD("get_repeat"), &MMCircleMap::get_repeat);
ClassDB::bind_method(D_METHOD("set_repeat", "value"), &MMCircleMap::set_repeat);
ADD_PROPERTY(PropertyInfo(Variant::INT, "repeat"), "set_repeat", "get_repeat");
} }
void CircleMap::set_radius(const float val) {
radius = val;
if (radius == 0) {
radius = 0.000000001;
}
set_dirty(true);
}
//repeat;
int CircleMap::get_repeat() {
return repeat;
}
void CircleMap::set_repeat(const int val) {
repeat = val;
set_dirty(true);
}
}
CircleMap::CircleMap() {
image;
input;
radius = 1;
repeat = 1;
}
CircleMap::~CircleMap() {
}
static void CircleMap::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_image"), &CircleMap::get_image);
ClassDB::bind_method(D_METHOD("set_image", "value"), &CircleMap::set_image);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref<Resource>"), "set_image", "get_image");
ClassDB::bind_method(D_METHOD("get_input"), &CircleMap::get_input);
ClassDB::bind_method(D_METHOD("set_input", "value"), &CircleMap::set_input);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref<Resource>"), "set_input", "get_input");
ClassDB::bind_method(D_METHOD("get_radius"), &CircleMap::get_radius);
ClassDB::bind_method(D_METHOD("set_radius", "value"), &CircleMap::set_radius);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "radius"), "set_radius", "get_radius");
ClassDB::bind_method(D_METHOD("get_repeat"), &CircleMap::get_repeat);
ClassDB::bind_method(D_METHOD("set_repeat", "value"), &CircleMap::set_repeat);
ADD_PROPERTY(PropertyInfo(Variant::INT, "repeat"), "set_repeat", "get_repeat");
ClassDB::bind_method(D_METHOD("_init_properties"), &CircleMap::_init_properties);
ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &CircleMap::_register_methods);
ClassDB::bind_method(D_METHOD("_render", "material"), &CircleMap::_render);
ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &CircleMap::_get_value_for);
ClassDB::bind_method(D_METHOD("get_radius"), &CircleMap::get_radius);
ClassDB::bind_method(D_METHOD("set_radius", "val"), &CircleMap::set_radius);
ClassDB::bind_method(D_METHOD("get_repeat"), &CircleMap::get_repeat);
ClassDB::bind_method(D_METHOD("set_repeat", "val"), &CircleMap::set_repeat);
}

65
modules/material_maker/nodes/transform/circle_map.h
View File

@ -1,51 +1,40 @@
#ifndef CIRCLE_MAP_H #ifndef MM_CIRCLE_MAP_H
#define CIRCLE_MAP_H #define MM_CIRCLE_MAP_H
#include "../mm_node.h"
#include "../mm_node_universal_property.h"
class CircleMap : public MMNode { class MMCircleMap : public MMNode {
GDCLASS(CircleMap, MMNode); GDCLASS(MMCircleMap, MMNode);
public: public:
Ref<MMNodeUniversalProperty> get_image();
void set_image(const Ref<MMNodeUniversalProperty> &val);
Ref<Resource> get_image(); Ref<MMNodeUniversalProperty> get_input();
void set_image(const Ref<Resource> &val); void set_input(const Ref<MMNodeUniversalProperty> &val);
Ref<Resource> get_input(); float get_radius() const;
void set_input(const Ref<Resource> &val); void set_radius(const float val);
float get_radius() const; int get_repeat() const;
void set_radius(const float val); void set_repeat(const int val);
int get_repeat() const; void _init_properties();
void set_repeat(const int val); void _register_methods(MMGraphNode *mm_graph_node);
void _render(const Ref<MMMaterial> &material);
Color _get_value_for(const Vector2 &uv, const int pseed);
void _init_properties(); MMCircleMap();
void _register_methods(const Variant &mm_graph_node); ~MMCircleMap();
void _render(const Variant &material);
Color _get_value_for(const Vector2 &uv, const int pseed);
float get_radius();
void set_radius(const float val);
int get_repeat();
void set_repeat(const int val);
CircleMap(); protected:
~CircleMap(); static void _bind_methods();
protected: Ref<MMNodeUniversalProperty> image;
static void _bind_methods(); Ref<MMNodeUniversalProperty> input;
float radius = 1;
//tool int repeat = 1;
//export(Resource)
Ref<Resource> image;
//export(Resource)
Ref<Resource> input;
//export(float)
float radius = 1;
//export(int)
int repeat = 1;
//radius
//repeat
}; };
#endif #endif

877
modules/material_maker/nodes/transform/color_tiler.cpp
View File

@ -1,609 +1,412 @@
#include "color_tiler.h" #include "color_tiler.h"
#include "../../algos/mm_algos.h"
#include "../../editor/mm_graph_node.h"
#include "../mm_material.h"
Ref<Resource> ColorTiler::get_input() { Ref<MMNodeUniversalProperty> MMColorTiler::get_input() {
return input; return input;
} }
void ColorTiler::set_input(const Ref<Resource> &val) { void MMColorTiler::set_input(const Ref<MMNodeUniversalProperty> &val) {
input = val; input = val;
} }
Ref<MMNodeUniversalProperty> MMColorTiler::get_in_mask() {
Ref<Resource> ColorTiler::get_in_mask() { return in_mask;
return in_mask;
}
void ColorTiler::set_in_mask(const Ref<Resource> &val) {
in_mask = val;
}
Ref<Resource> ColorTiler::get_output() {
return output;
}
void ColorTiler::set_output(const Ref<Resource> &val) {
output = val;
}
Ref<Resource> ColorTiler::get_instance_map() {
return instance_map;
}
void ColorTiler::set_instance_map(const Ref<Resource> &val) {
instance_map = val;
}
Vector2 ColorTiler::get_tile() {
return tile;
}
void ColorTiler::set_tile(const Vector2 &val) {
tile = val;
}
float ColorTiler::get_overlap() const {
return overlap;
}
void ColorTiler::set_overlap(const float val) {
overlap = val;
}
int ColorTiler::get_select_inputs() const {
return select_inputs;
}
void ColorTiler::set_select_inputs(const int val) {
select_inputs = val;
}
Vector2 ColorTiler::get_scale() {
return scale;
}
void ColorTiler::set_scale(const Vector2 &val) {
scale = val;
}
float ColorTiler::get_fixed_offset() const {
return fixed_offset;
}
void ColorTiler::set_fixed_offset(const float val) {
fixed_offset = val;
}
float ColorTiler::get_rnd_offset() const {
return rnd_offset;
}
void ColorTiler::set_rnd_offset(const float val) {
rnd_offset = val;
}
float ColorTiler::get_rnd_rotate() const {
return rnd_rotate;
}
void ColorTiler::set_rnd_rotate(const float val) {
rnd_rotate = val;
}
float ColorTiler::get_rnd_scale() const {
return rnd_scale;
}
void ColorTiler::set_rnd_scale(const float val) {
rnd_scale = val;
}
float ColorTiler::get_rnd_opacity() const {
return rnd_opacity;
}
void ColorTiler::set_rnd_opacity(const float val) {
rnd_opacity = val;
}
bool ColorTiler::get_variations() const {
return variations;
}
void ColorTiler::set_variations(const bool val) {
variations = val;
}
//tool;
//export(Resource) ;
Ref<Resource> input;
//export(Resource) ;
Ref<Resource> in_mask;
//export(Resource) ;
Ref<Resource> output;
//export(Resource) ;
Ref<Resource> instance_map;
//export(Vector2) ;
Vector2 tile = Vector2(4, 4);
//export(float) ;
float overlap = 1;
//export(int, "1,4,16") ;
int select_inputs = 0;
//export(Vector2) ;
Vector2 scale = Vector2(0.5, 0.5);
//export(float) ;
float fixed_offset = 0;
//export(float) ;
float rnd_offset = 0.25;
//export(float) ;
float rnd_rotate = 45;
//export(float) ;
float rnd_scale = 0.2;
//export(float) ;
float rnd_opacity = 0;
//export(bool) ;
bool variations = false;
void ColorTiler::_init_properties() {
if (!input) {
input = MMNodeUniversalProperty.new();
input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR;
input.set_default_value(Color(0, 0, 0, 1));
}
input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL;
input.slot_name = ">>> Input ";
if (!in_mask) {
in_mask = MMNodeUniversalProperty.new();
in_mask.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_FLOAT;
in_mask.set_default_value(1);
}
in_mask.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL;
in_mask.slot_name = ">>> Mask ";
if (!output) {
output = MMNodeUniversalProperty.new();
output.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE;
} }
output.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; void MMColorTiler::set_in_mask(const Ref<MMNodeUniversalProperty> &val) {
in_mask = val;
if (!instance_map) {
instance_map = MMNodeUniversalProperty.new();
instance_map.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE;
} }
instance_map.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; Ref<MMNodeUniversalProperty> MMColorTiler::get_output() {
register_input_property(input); return output;
register_input_property(in_mask);
register_output_property(output);
register_output_property(instance_map);
} }
void MMColorTiler::set_output(const Ref<MMNodeUniversalProperty> &val) {
void ColorTiler::_register_methods(const Variant &mm_graph_node) { output = val;
mm_graph_node.add_slot_label_universal(input);
mm_graph_node.add_slot_label_universal(in_mask);
mm_graph_node.add_slot_texture_universal(output);
mm_graph_node.add_slot_texture_universal(instance_map);
mm_graph_node.add_slot_vector2("get_tile", "set_tile", "Tile", 1);
mm_graph_node.add_slot_float("get_overlap", "set_overlap", "Overlap", 1);
mm_graph_node.add_slot_enum("get_select_inputs", "set_select_inputs", "Select inputs", [ "1", "4", "16" ]);
mm_graph_node.add_slot_vector2("get_scale", "set_scale", "Scale", 0.01);
mm_graph_node.add_slot_float("get_fixed_offset", "set_fixed_offset", "Fixed Offset", 0.01);
mm_graph_node.add_slot_float("get_rnd_offset", "set_rnd_offset", "Rnd Offset", 0.01);
mm_graph_node.add_slot_float("get_rnd_rotate", "set_rnd_rotate", "Rnd Rotate", 0.1);
mm_graph_node.add_slot_float("get_rnd_scale", "set_rnd_scale", "Rnd Scale", 0.01);
mm_graph_node.add_slot_float("get_rnd_opacity", "set_rnd_opacity", "Rnd Opacity", 0.01);
} }
//mm_graph_node.add_slot_bool("get_variations", "set_variations", "Variations"); Ref<MMNodeUniversalProperty> MMColorTiler::get_instance_map() {
return instance_map;
void ColorTiler::_render(const Variant &material) {
Ref<Image> output_img = Image.new();
Ref<Image> instance_map_img = Image.new();
output_img.create(material.image_size.x, material.image_size.y, false, Image.FORMAT_RGBA8);
instance_map_img.create(material.image_size.x, material.image_size.y, false, Image.FORMAT_RGBA8);
output_img.lock();
instance_map_img.lock();
float w = material.image_size.x;
float h = material.image_size.y;
float pseed = randf() + randi();
float ps = 1.0 / float(pseed);
int ix = int(material.image_size.x);
int iy = int(material.image_size.y);
for (int x = 0; x < ix; ++x) { //x in range(ix)
for (int y = 0; y < iy; ++y) { //y in range(iy)
Vector2 uv = Vector2(x / w, y / h);
//vec3 $(name_uv)_random_color;
//vec4 $(name_uv)_tiled_output = tiler_$(name)($uv, vec2($tx, $ty), int($overlap), vec2(float($seed)), $(name_uv)_random_color);
PoolColorArray rch = tiler_calc(uv, tile, overlap, Vector2(ps, ps));
output_img.set_pixel(x, y, rch[1]);
instance_map_img.set_pixel(x, y, rch[0]);
} }
void MMColorTiler::set_instance_map(const Ref<MMNodeUniversalProperty> &val) {
instance_map = val;
} }
output_img.unlock(); Vector2 MMColorTiler::get_tile() {
instance_map_img.unlock(); return tile;
output.set_value(output_img);
instance_map.set_value(instance_map_img);
} }
void MMColorTiler::set_tile(const Vector2 &val) {
Color ColorTiler::_get_value_for(const Vector2 &uv, const int pseed) { tile = val;
return Color(); set_dirty(true);
} }
//tile; float MMColorTiler::get_overlap() const {
return overlap;
Vector2 ColorTiler::get_tile() {
return tile;
} }
void MMColorTiler::set_overlap(const float val) {
void ColorTiler::set_tile(const Vector2 &val) { overlap = val;
tile = val; set_dirty(true);
set_dirty(true);
} }
//overlap; int MMColorTiler::get_select_inputs() const {
return select_inputs;
float ColorTiler::get_overlap() {
return overlap;
} }
void MMColorTiler::set_select_inputs(const int val) {
void ColorTiler::set_overlap(const float val) { select_inputs = val;
overlap = val; set_dirty(true);
set_dirty(true);
} }
//select_inputs; Vector2 MMColorTiler::get_scale() {
return scale;
int ColorTiler::get_select_inputs() {
return select_inputs;
} }
void MMColorTiler::set_scale(const Vector2 &val) {
void ColorTiler::set_select_inputs(const int val) { scale = val;
select_inputs = val; set_dirty(true);
set_dirty(true);
} }
//scale; float MMColorTiler::get_fixed_offset() const {
return fixed_offset;
Vector2 ColorTiler::get_scale() {
return scale;
} }
void MMColorTiler::set_fixed_offset(const float val) {
void ColorTiler::set_scale(const Vector2 &val) { fixed_offset = val;
scale = val; set_dirty(true);
set_dirty(true);
} }
//fixed_offset; float MMColorTiler::get_rnd_offset() const {
return rnd_offset;
float ColorTiler::get_fixed_offset() {
return fixed_offset;
} }
void MMColorTiler::set_rnd_offset(const float val) {
void ColorTiler::set_fixed_offset(const float val) { rnd_offset = val;
fixed_offset = val; set_dirty(true);
set_dirty(true);
} }
//rnd_offset; float MMColorTiler::get_rnd_rotate() const {
return rnd_rotate;
float ColorTiler::get_rnd_offset() {
return rnd_offset;
} }
void MMColorTiler::set_rnd_rotate(const float val) {
void ColorTiler::set_rnd_offset(const float val) { rnd_rotate = val;
rnd_offset = val; set_dirty(true);
set_dirty(true);
} }
//rnd_rotate; float MMColorTiler::get_rnd_scale() const {
return rnd_scale;
float ColorTiler::get_rnd_rotate() {
return rnd_rotate;
} }
void MMColorTiler::set_rnd_scale(const float val) {
void ColorTiler::set_rnd_rotate(const float val) { rnd_scale = val;
rnd_rotate = val; set_dirty(true);
set_dirty(true);
}
//rnd_scale;
float ColorTiler::get_rnd_scale() {
return rnd_scale;
} }
float MMColorTiler::get_rnd_opacity() const {
void ColorTiler::set_rnd_scale(const float val) { return rnd_opacity;
rnd_scale = val;
set_dirty(true);
}
//rnd_opacity;
float ColorTiler::get_rnd_opacity() {
return rnd_opacity;
} }
void MMColorTiler::set_rnd_opacity(const float val) {
void ColorTiler::set_rnd_opacity(const float val) { rnd_opacity = val;
rnd_opacity = val; set_dirty(true);
set_dirty(true);
} }
//variations; bool MMColorTiler::get_variations() const {
return variations;
bool ColorTiler::get_variations() {
return variations;
} }
void MMColorTiler::set_variations(const bool val) {
void ColorTiler::set_variations(const bool val) { variations = val;
variations = val; set_dirty(true);
set_dirty(true);
} }
//----------------------; void MMColorTiler::_init_properties() {
//color_tiler.mmg; if (!input.is_valid()) {
//Tiles several occurences of an input image while adding randomness.; input.instance();
//vec4 tiler_$(name)(vec2 uv, vec2 tile, int overlap, vec2 _seed, out vec3 random_color) {; input->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_COLOR);
// vec4 c = vec4(0.0); input->set_default_value(Color(0, 0, 0, 1));
// vec3 rc = vec3(0.0); }
// vec3 rc1;
//;
// for (int dx = -overlap; dx <= overlap; ++dx) {;
// for (int dy = -overlap; dy <= overlap; ++dy) {;
// vec2 pos = fract((floor(uv*tile)+vec2(float(dx), float(dy))+vec2(0.5))/tile-vec2(0.5));
// vec2 seed = rand2(pos+_seed);
// rc1 = rand3(seed);
// pos = fract(pos+vec2($fixed_offset/tile.x, 0.0)*floor(mod(pos.y*tile.y, 2.0))+$offset*seed/tile);
// float mask = $mask(fract(pos+vec2(0.5)));
// if (mask > 0.01) {;
// vec2 pv = fract(uv - pos)-vec2(0.5);
// seed = rand2(seed);
// float angle = (seed.x * 2.0 - 1.0) * $rotate * 0.01745329251;
// float ca = cos(angle);
// float sa = sin(angle);
// pv = vec2(ca*pv.x+sa*pv.y, -sa*pv.x+ca*pv.y);
// pv *= (seed.y-0.5)*2.0*$scale+1.0;
// pv /= vec2($scale_x, $scale_y);
// pv += vec2(0.5);
// pv = clamp(pv, vec2(0.0), vec2(1.0));
//;
// $select_inputs;
//;
// vec4 n = $in.variation(pv, $variations ? seed.x : 0.0);
//;
// seed = rand2(seed);
// float na = n.a*mask*(1.0-$opacity*seed.x);
// float a = (1.0-c.a)*(1.0*na);
//;
// c = mix(c, n, na);
// rc = mix(rc, rc1, n.a);
// };
// };
// };
//;
// random_color = rc;
// return c;
//};
//select_inputs enum;
//1, " ";
//4, "pv = clamp(0.5*(pv+floor(rand2(seed)*2.0)), vec2(0.0), vec2(1.0));";
//16, "pv = clamp(0.25*(pv+floor(rand2(seed)*4.0)), vec2(0.0), vec2(1.0));";
PoolColorArray ColorTiler::tiler_calc(const Vector2 &uv, const Vector2 &tile, const int overlap, const Vector2 &_seed) { input->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL);
Color c = Color(); input->set_slot_name(">>> Input ");
Vector3 rc = Vector3();
Vector3 rc1 = Vector3();
//for (int dx = -overlap; dx <= overlap; ++dx) {;
for (int dx = -overlap; dx < overlap; ++dx) { //dx in range(-overlap, overlap) if (!in_mask.is_valid()) {
//for (int dy = -overlap; dy <= overlap; ++dy) {; in_mask.instance();
in_mask->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_FLOAT);
in_mask->set_default_value(1);
}
for (int dy = -overlap; dy < overlap; ++dy) { //dy in range(-overlap, overlap) in_mask->set_input_slot_type(MMNodeUniversalProperty::SLOT_TYPE_UNIVERSAL);
Vector2 pos = MMAlgos.fractv2((MMAlgos.floorv2(uv * tile) + Vector2(dx, dy) + Vector2(0.5, 0.5)) / tile - Vector2(0.5, 0.5)); in_mask->set_slot_name(">>> Mask ");
Vector2 vseed = MMAlgos.rand2(pos + _seed);
rc1 = MMAlgos.rand3(vseed);
pos = MMAlgos.fractv2(pos + Vector2(fixed_offset / tile.x, 0.0) * floor(MMAlgos.modf(pos.y * tile.y, 2.0)) + rnd_offset * vseed / tile);
float mask = in_mask.get_value(MMAlgos.fractv2(pos + Vector2(0.5, 0.5)));
if ((mask > 0.01)) { if (!output.is_valid()) {
Vector2 pv = MMAlgos.fractv2(uv - pos) - Vector2(0.5, 0.5); output.instance();
vseed = MMAlgos.rand2(vseed); output->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE);
float angle = (vseed.x * 2.0 - 1.0) * rnd_rotate * 0.01745329251; }
float ca = cos(angle);
float sa = sin(angle);
pv = Vector2(ca * pv.x + sa * pv.y, -sa * pv.x + ca * pv.y);
pv *= (vseed.y-0.5) * 2.0 * rnd_scale + 1.0;
pv /= scale;
pv += Vector2(0.5, 0.5);
pv = MMAlgos.clampv2(pv, Vector2(), Vector2(1, 1));
//1, " ";
//4, "pv = clamp(0.5*(pv+floor(rand2(seed)*2.0)), vec2(0.0), vec2(1.0));";
//16, "pv = clamp(0.25*(pv+floor(rand2(seed)*4.0)), vec2(0.0), vec2(1.0));";
if (select_inputs == 1) { output->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE);
pv = MMAlgos.clampv2(0.5*(pv + MMAlgos.floorv2(MMAlgos.rand2(vseed)*2.0)), Vector2(), Vector2(1, 1));
}
if (!instance_map.is_valid()) {
instance_map.instance();
instance_map->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE);
}
else if (select_inputs == 2) { instance_map->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE);
pv = MMAlgos.clampv2(0.25*(pv + MMAlgos.floorv2(MMAlgos.rand2(vseed)*4.0)), Vector2(), Vector2(1, 1));
}
// vec4 n = $in.variation(pv, $variations ? seed.x : 0.0);
Color n = input.get_value(pv) * mask * (1.0 - rnd_opacity * vseed.x);
vseed = MMAlgos.rand2(vseed);
float na = n.a * mask * (1.0 - rnd_opacity * vseed.x);
float a = (1.0 - c.a) * (1.0 * na);
c = lerp(c, n, na);
rc = lerp(rc, rc1, n.a);
}
}
register_input_property(input);
register_input_property(in_mask);
register_output_property(output);
register_output_property(instance_map);
} }
PoolColorArray pc = PoolColorArray(); void MMColorTiler::_register_methods(MMGraphNode *mm_graph_node) {
pc.append(Color(rc.x, rc.y, rc.z, 1)); mm_graph_node->add_slot_label_universal(input);
pc.append(c); mm_graph_node->add_slot_label_universal(in_mask);
return pc; mm_graph_node->add_slot_texture_universal(output);
} mm_graph_node->add_slot_texture_universal(instance_map);
mm_graph_node->add_slot_vector2("get_tile", "set_tile", "Tile", 1);
mm_graph_node->add_slot_float("get_overlap", "set_overlap", "Overlap", 1);
Array arr;
arr.push_back("1");
arr.push_back("4");
arr.push_back("16");
mm_graph_node->add_slot_enum("get_select_inputs", "set_select_inputs", "Select inputs", arr);
mm_graph_node->add_slot_vector2("get_scale", "set_scale", "Scale", 0.01);
mm_graph_node->add_slot_float("get_fixed_offset", "set_fixed_offset", "Fixed Offset", 0.01);
mm_graph_node->add_slot_float("get_rnd_offset", "set_rnd_offset", "Rnd Offset", 0.01);
mm_graph_node->add_slot_float("get_rnd_rotate", "set_rnd_rotate", "Rnd Rotate", 0.1);
mm_graph_node->add_slot_float("get_rnd_scale", "set_rnd_scale", "Rnd Scale", 0.01);
mm_graph_node->add_slot_float("get_rnd_opacity", "set_rnd_opacity", "Rnd Opacity", 0.01);
}
//mm_graph_node.add_slot_bool("get_variations", "set_variations", "Variations");
void MMColorTiler::_render(const Ref<MMMaterial> &material) {
Ref<Image> output_img;
output_img.instance();
Ref<Image> instance_map_img;
instance_map_img.instance();
output_img->create(material->image_size.x, material->image_size.y, false, Image::FORMAT_RGBA8);
instance_map_img->create(material->image_size.x, material->image_size.y, false, Image::FORMAT_RGBA8);
output_img->lock();
instance_map_img->lock();
float w = material->image_size.x;
float h = material->image_size.y;
float pseed = Math::randf() + Math::rand();
float ps = 1.0 / float(pseed);
int ix = int(material->image_size.x);
int iy = int(material->image_size.y);
for (int x = 0; x < ix; ++x) { //x in range(ix)
for (int y = 0; y < iy; ++y) { //y in range(iy)
Vector2 uv = Vector2(x / w, y / h);
//vec3 $(name_uv)_random_color;
//vec4 $(name_uv)_tiled_output = tiler_$(name)($uv, vec2($tx, $ty), int($overlap), vec2(float($seed)), $(name_uv)_random_color);
PoolColorArray rch = tiler_calc(uv, tile, overlap, Vector2(ps, ps));
output_img->set_pixel(x, y, rch[1]);
instance_map_img->set_pixel(x, y, rch[0]);
}
}
output_img->unlock();
instance_map_img->unlock();
output->set_value(output_img);
instance_map->set_value(instance_map_img);
}
Color MMColorTiler::_get_value_for(const Vector2 &uv, const int pseed) {
return Color();
}
//----------------------;
//color_tiler.mmg;
//Tiles several occurences of an input image while adding randomness.;
//vec4 tiler_$(name)(vec2 uv, vec2 tile, int overlap, vec2 _seed, out vec3 random_color) {;
// vec4 c = vec4(0.0);
// vec3 rc = vec3(0.0);
// vec3 rc1;
//;
// for (int dx = -overlap; dx <= overlap; ++dx) {;
// for (int dy = -overlap; dy <= overlap; ++dy) {;
// vec2 pos = fract((floor(uv*tile)+vec2(float(dx), float(dy))+vec2(0.5))/tile-vec2(0.5));
// vec2 seed = rand2(pos+_seed);
// rc1 = rand3(seed);
// pos = fract(pos+vec2($fixed_offset/tile.x, 0.0)*floor(mod(pos.y*tile.y, 2.0))+$offset*seed/tile);
// float mask = $mask(fract(pos+vec2(0.5)));
// if (mask > 0.01) {;
// vec2 pv = fract(uv - pos)-vec2(0.5);
// seed = rand2(seed);
// float angle = (seed.x * 2.0 - 1.0) * $rotate * 0.01745329251;
// float ca = cos(angle);
// float sa = sin(angle);
// pv = vec2(ca*pv.x+sa*pv.y, -sa*pv.x+ca*pv.y);
// pv *= (seed.y-0.5)*2.0*$scale+1.0;
// pv /= vec2($scale_x, $scale_y);
// pv += vec2(0.5);
// pv = clamp(pv, vec2(0.0), vec2(1.0));
//;
// $select_inputs;
//;
// vec4 n = $in.variation(pv, $variations ? seed.x : 0.0);
//;
// seed = rand2(seed);
// float na = n.a*mask*(1.0-$opacity*seed.x);
// float a = (1.0-c.a)*(1.0*na);
//;
// c = mix(c, n, na);
// rc = mix(rc, rc1, n.a);
// };
// };
// };
//;
// random_color = rc;
// return c;
//};
//select_inputs enum;
//1, " ";
//4, "pv = clamp(0.5*(pv+floor(rand2(seed)*2.0)), vec2(0.0), vec2(1.0));";
//16, "pv = clamp(0.25*(pv+floor(rand2(seed)*4.0)), vec2(0.0), vec2(1.0));";
PoolColorArray MMColorTiler::tiler_calc(const Vector2 &uv, const Vector2 &tile, const int overlap, const Vector2 &_seed) {
Color c = Color();
Vector3 rc = Vector3();
Vector3 rc1 = Vector3();
//for (int dx = -overlap; dx <= overlap; ++dx) {;
for (int dx = -overlap; dx < overlap; ++dx) { //dx in range(-overlap, overlap)
//for (int dy = -overlap; dy <= overlap; ++dy) {;
for (int dy = -overlap; dy < overlap; ++dy) { //dy in range(-overlap, overlap)
Vector2 pos = MMAlgos::fractv2((MMAlgos::floorv2(uv * tile) + Vector2(dx, dy) + Vector2(0.5, 0.5)) / tile - Vector2(0.5, 0.5));
Vector2 vseed = MMAlgos::rand2(pos + _seed);
rc1 = MMAlgos::rand3(vseed);
pos = MMAlgos::fractv2(pos + Vector2(fixed_offset / tile.x, 0.0) * floor(MMAlgos::modf(pos.y * tile.y, 2.0)) + rnd_offset * vseed / tile);
float mask = in_mask->get_value(MMAlgos::fractv2(pos + Vector2(0.5, 0.5)));
if ((mask > 0.01)) {
Vector2 pv = MMAlgos::fractv2(uv - pos) - Vector2(0.5, 0.5);
vseed = MMAlgos::rand2(vseed);
float angle = (vseed.x * 2.0 - 1.0) * rnd_rotate * 0.01745329251;
float ca = cos(angle);
float sa = sin(angle);
pv = Vector2(ca * pv.x + sa * pv.y, -sa * pv.x + ca * pv.y);
pv *= (vseed.y - 0.5) * 2.0 * rnd_scale + 1.0;
pv /= scale;
pv += Vector2(0.5, 0.5);
pv = MMAlgos::clampv2(pv, Vector2(), Vector2(1, 1));
//1, " ";
//4, "pv = clamp(0.5*(pv+floor(rand2(seed)*2.0)), vec2(0.0), vec2(1.0));";
//16, "pv = clamp(0.25*(pv+floor(rand2(seed)*4.0)), vec2(0.0), vec2(1.0));";
if (select_inputs == 1) {
pv = MMAlgos::clampv2(0.5 * (pv + MMAlgos::floorv2(MMAlgos::rand2(vseed) * 2.0)), Vector2(), Vector2(1, 1));
}
else if (select_inputs == 2) {
pv = MMAlgos::clampv2(0.25 * (pv + MMAlgos::floorv2(MMAlgos::rand2(vseed) * 4.0)), Vector2(), Vector2(1, 1));
}
// vec4 n = $in.variation(pv, $variations ? seed.x : 0.0);
Color inc = input->get_value(pv);
Color n = inc * mask * (1.0 - rnd_opacity * vseed.x);
vseed = MMAlgos::rand2(vseed);
float na = n.a * mask * (1.0 - rnd_opacity * vseed.x);
//float a = (1.0 - c.a) * (1.0 * na);
c = c.linear_interpolate(n, na);
rc = rc.linear_interpolate(rc1, n.a);
}
}
}
PoolColorArray pc = PoolColorArray();
pc.append(Color(rc.x, rc.y, rc.z, 1));
pc.append(c);
return pc;
}
MMColorTiler::MMColorTiler() {
tile = Vector2(4, 4);
overlap = 1;
select_inputs = 0;
scale = Vector2(0.5, 0.5);
fixed_offset = 0;
rnd_offset = 0.25;
rnd_rotate = 45;
rnd_scale = 0.2;
rnd_opacity = 0;
variations = false;
}
MMColorTiler::~MMColorTiler() {
}
void MMColorTiler::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_input"), &MMColorTiler::get_input);
ClassDB::bind_method(D_METHOD("set_input", "value"), &MMColorTiler::set_input);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_input", "get_input");
ClassDB::bind_method(D_METHOD("get_in_mask"), &MMColorTiler::get_in_mask);
ClassDB::bind_method(D_METHOD("set_in_mask", "value"), &MMColorTiler::set_in_mask);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "in_mask", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_in_mask", "get_in_mask");
ClassDB::bind_method(D_METHOD("get_output"), &MMColorTiler::get_output);
ClassDB::bind_method(D_METHOD("set_output", "value"), &MMColorTiler::set_output);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "output", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_output", "get_output");
ClassDB::bind_method(D_METHOD("get_instance_map"), &MMColorTiler::get_instance_map);
ClassDB::bind_method(D_METHOD("set_instance_map", "value"), &MMColorTiler::set_instance_map);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "instance_map", PROPERTY_HINT_RESOURCE_TYPE, "MMNodeUniversalProperty"), "set_instance_map", "get_instance_map");
ClassDB::bind_method(D_METHOD("get_tile"), &MMColorTiler::get_tile);
ClassDB::bind_method(D_METHOD("set_tile", "value"), &MMColorTiler::set_tile);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "tile"), "set_tile", "get_tile");
ClassDB::bind_method(D_METHOD("get_overlap"), &MMColorTiler::get_overlap);
ClassDB::bind_method(D_METHOD("set_overlap", "value"), &MMColorTiler::set_overlap);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "overlap"), "set_overlap", "get_overlap");
ClassDB::bind_method(D_METHOD("get_select_inputs"), &MMColorTiler::get_select_inputs);
ClassDB::bind_method(D_METHOD("set_select_inputs", "value"), &MMColorTiler::set_select_inputs);
ADD_PROPERTY(PropertyInfo(Variant::INT, "select_inputs"), "set_select_inputs", "get_select_inputs");
ClassDB::bind_method(D_METHOD("get_scale"), &MMColorTiler::get_scale);
ClassDB::bind_method(D_METHOD("set_scale", "value"), &MMColorTiler::set_scale);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "scale"), "set_scale", "get_scale");
ClassDB::bind_method(D_METHOD("get_fixed_offset"), &MMColorTiler::get_fixed_offset);
ClassDB::bind_method(D_METHOD("set_fixed_offset", "value"), &MMColorTiler::set_fixed_offset);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "fixed_offset"), "set_fixed_offset", "get_fixed_offset");
ClassDB::bind_method(D_METHOD("get_rnd_offset"), &MMColorTiler::get_rnd_offset);
ClassDB::bind_method(D_METHOD("set_rnd_offset", "value"), &MMColorTiler::set_rnd_offset);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "rnd_offset"), "set_rnd_offset", "get_rnd_offset");
ClassDB::bind_method(D_METHOD("get_rnd_rotate"), &MMColorTiler::get_rnd_rotate);
ClassDB::bind_method(D_METHOD("set_rnd_rotate", "value"), &MMColorTiler::set_rnd_rotate);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "rnd_rotate"), "set_rnd_rotate", "get_rnd_rotate");
ClassDB::bind_method(D_METHOD("get_rnd_scale"), &MMColorTiler::get_rnd_scale);
ClassDB::bind_method(D_METHOD("set_rnd_scale", "value"), &MMColorTiler::set_rnd_scale);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "rnd_scale"), "set_rnd_scale", "get_rnd_scale");
ClassDB::bind_method(D_METHOD("get_rnd_opacity"), &MMColorTiler::get_rnd_opacity);
ClassDB::bind_method(D_METHOD("set_rnd_opacity", "value"), &MMColorTiler::set_rnd_opacity);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "rnd_opacity"), "set_rnd_opacity", "get_rnd_opacity");
ClassDB::bind_method(D_METHOD("get_variations"), &MMColorTiler::get_variations);
ClassDB::bind_method(D_METHOD("set_variations", "value"), &MMColorTiler::set_variations);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "variations"), "set_variations", "get_variations");
ClassDB::bind_method(D_METHOD("tiler_calc", "uv", "tile", "overlap", "_seed"), &MMColorTiler::tiler_calc);
} }
ColorTiler::ColorTiler() {
input;
in_mask;
output;
instance_map;
tile = Vector2(4, 4);
overlap = 1;
select_inputs = 0;
scale = Vector2(0.5, 0.5);
fixed_offset = 0;
rnd_offset = 0.25;
rnd_rotate = 45;
rnd_scale = 0.2;
rnd_opacity = 0;
variations = false;
}
ColorTiler::~ColorTiler() {
}
static void ColorTiler::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_input"), &ColorTiler::get_input);
ClassDB::bind_method(D_METHOD("set_input", "value"), &ColorTiler::set_input);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref<Resource>"), "set_input", "get_input");
ClassDB::bind_method(D_METHOD("get_in_mask"), &ColorTiler::get_in_mask);
ClassDB::bind_method(D_METHOD("set_in_mask", "value"), &ColorTiler::set_in_mask);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "in_mask", PROPERTY_HINT_RESOURCE_TYPE, "Ref<Resource>"), "set_in_mask", "get_in_mask");
ClassDB::bind_method(D_METHOD("get_output"), &ColorTiler::get_output);
ClassDB::bind_method(D_METHOD("set_output", "value"), &ColorTiler::set_output);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "output", PROPERTY_HINT_RESOURCE_TYPE, "Ref<Resource>"), "set_output", "get_output");
ClassDB::bind_method(D_METHOD("get_instance_map"), &ColorTiler::get_instance_map);
ClassDB::bind_method(D_METHOD("set_instance_map", "value"), &ColorTiler::set_instance_map);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "instance_map", PROPERTY_HINT_RESOURCE_TYPE, "Ref<Resource>"), "set_instance_map", "get_instance_map");
ClassDB::bind_method(D_METHOD("get_tile"), &ColorTiler::get_tile);
ClassDB::bind_method(D_METHOD("set_tile", "value"), &ColorTiler::set_tile);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "tile"), "set_tile", "get_tile");
ClassDB::bind_method(D_METHOD("get_overlap"), &ColorTiler::get_overlap);
ClassDB::bind_method(D_METHOD("set_overlap", "value"), &ColorTiler::set_overlap);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "overlap"), "set_overlap", "get_overlap");
ClassDB::bind_method(D_METHOD("get_select_inputs"), &ColorTiler::get_select_inputs);
ClassDB::bind_method(D_METHOD("set_select_inputs", "value"), &ColorTiler::set_select_inputs);
ADD_PROPERTY(PropertyInfo(Variant::INT, "select_inputs"), "set_select_inputs", "get_select_inputs");
ClassDB::bind_method(D_METHOD("get_scale"), &ColorTiler::get_scale);
ClassDB::bind_method(D_METHOD("set_scale", "value"), &ColorTiler::set_scale);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "scale"), "set_scale", "get_scale");
ClassDB::bind_method(D_METHOD("get_fixed_offset"), &ColorTiler::get_fixed_offset);
ClassDB::bind_method(D_METHOD("set_fixed_offset", "value"), &ColorTiler::set_fixed_offset);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "fixed_offset"), "set_fixed_offset", "get_fixed_offset");
ClassDB::bind_method(D_METHOD("get_rnd_offset"), &ColorTiler::get_rnd_offset);
ClassDB::bind_method(D_METHOD("set_rnd_offset", "value"), &ColorTiler::set_rnd_offset);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "rnd_offset"), "set_rnd_offset", "get_rnd_offset");
ClassDB::bind_method(D_METHOD("get_rnd_rotate"), &ColorTiler::get_rnd_rotate);
ClassDB::bind_method(D_METHOD("set_rnd_rotate", "value"), &ColorTiler::set_rnd_rotate);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "rnd_rotate"), "set_rnd_rotate", "get_rnd_rotate");
ClassDB::bind_method(D_METHOD("get_rnd_scale"), &ColorTiler::get_rnd_scale);
ClassDB::bind_method(D_METHOD("set_rnd_scale", "value"), &ColorTiler::set_rnd_scale);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "rnd_scale"), "set_rnd_scale", "get_rnd_scale");
ClassDB::bind_method(D_METHOD("get_rnd_opacity"), &ColorTiler::get_rnd_opacity);
ClassDB::bind_method(D_METHOD("set_rnd_opacity", "value"), &ColorTiler::set_rnd_opacity);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "rnd_opacity"), "set_rnd_opacity", "get_rnd_opacity");
ClassDB::bind_method(D_METHOD("get_variations"), &ColorTiler::get_variations);
ClassDB::bind_method(D_METHOD("set_variations", "value"), &ColorTiler::set_variations);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "variations"), "set_variations", "get_variations");
ClassDB::bind_method(D_METHOD("_init_properties"), &ColorTiler::_init_properties);
ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &ColorTiler::_register_methods);
ClassDB::bind_method(D_METHOD("_render", "material"), &ColorTiler::_render);
ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &ColorTiler::_get_value_for);
ClassDB::bind_method(D_METHOD("get_tile"), &ColorTiler::get_tile);
ClassDB::bind_method(D_METHOD("set_tile", "val"), &ColorTiler::set_tile);
ClassDB::bind_method(D_METHOD("get_overlap"), &ColorTiler::get_overlap);
ClassDB::bind_method(D_METHOD("set_overlap", "val"), &ColorTiler::set_overlap);
ClassDB::bind_method(D_METHOD("get_select_inputs"), &ColorTiler::get_select_inputs);
ClassDB::bind_method(D_METHOD("set_select_inputs", "val"), &ColorTiler::set_select_inputs);
ClassDB::bind_method(D_METHOD("get_scale"), &ColorTiler::get_scale);
ClassDB::bind_method(D_METHOD("set_scale", "val"), &ColorTiler::set_scale);
ClassDB::bind_method(D_METHOD("get_fixed_offset"), &ColorTiler::get_fixed_offset);
ClassDB::bind_method(D_METHOD("set_fixed_offset", "val"), &ColorTiler::set_fixed_offset);
ClassDB::bind_method(D_METHOD("get_rnd_offset"), &ColorTiler::get_rnd_offset);
ClassDB::bind_method(D_METHOD("set_rnd_offset", "val"), &ColorTiler::set_rnd_offset);
ClassDB::bind_method(D_METHOD("get_rnd_rotate"), &ColorTiler::get_rnd_rotate);
ClassDB::bind_method(D_METHOD("set_rnd_rotate", "val"), &ColorTiler::set_rnd_rotate);
ClassDB::bind_method(D_METHOD("get_rnd_scale"), &ColorTiler::get_rnd_scale);
ClassDB::bind_method(D_METHOD("set_rnd_scale", "val"), &ColorTiler::set_rnd_scale);
ClassDB::bind_method(D_METHOD("get_rnd_opacity"), &ColorTiler::get_rnd_opacity);
ClassDB::bind_method(D_METHOD("set_rnd_opacity", "val"), &ColorTiler::set_rnd_opacity);
ClassDB::bind_method(D_METHOD("get_variations"), &ColorTiler::get_variations);
ClassDB::bind_method(D_METHOD("set_variations", "val"), &ColorTiler::set_variations);
ClassDB::bind_method(D_METHOD("tiler_calc", "uv", "tile", "overlap", "_seed"), &ColorTiler::tiler_calc);
}

211
modules/material_maker/nodes/transform/color_tiler.h
View File

@ -1,175 +1,84 @@
#ifndef COLOR_TILER_H #ifndef MM_COLOR_TILER_H
#define COLOR_TILER_H #define MM_COLOR_TILER_H
#include "../mm_node.h"
#include "../mm_node_universal_property.h"
class ColorTiler : public MMNode { class MMColorTiler : public MMNode {
GDCLASS(ColorTiler, MMNode); GDCLASS(MMColorTiler, MMNode);
public: public:
Ref<MMNodeUniversalProperty> get_input();
void set_input(const Ref<MMNodeUniversalProperty> &val);
Ref<Resource> get_input(); Ref<MMNodeUniversalProperty> get_in_mask();
void set_input(const Ref<Resource> &val); void set_in_mask(const Ref<MMNodeUniversalProperty> &val);
Ref<Resource> get_in_mask(); Ref<MMNodeUniversalProperty> get_output();
void set_in_mask(const Ref<Resource> &val); void set_output(const Ref<MMNodeUniversalProperty> &val);
Ref<Resource> get_output(); Ref<MMNodeUniversalProperty> get_instance_map();
void set_output(const Ref<Resource> &val); void set_instance_map(const Ref<MMNodeUniversalProperty> &val);
Ref<Resource> get_instance_map(); Vector2 get_tile();
void set_instance_map(const Ref<Resource> &val); void set_tile(const Vector2 &val);
Vector2 get_tile(); float get_overlap() const;
void set_tile(const Vector2 &val); void set_overlap(const float val);
float get_overlap() const; int get_select_inputs() const;
void set_overlap(const float val); void set_select_inputs(const int val);
int get_select_inputs() const; Vector2 get_scale();
void set_select_inputs(const int val); void set_scale(const Vector2 &val);
Vector2 get_scale(); float get_fixed_offset() const;
void set_scale(const Vector2 &val); void set_fixed_offset(const float val);
float get_fixed_offset() const; float get_rnd_offset() const;
void set_fixed_offset(const float val); void set_rnd_offset(const float val);
float get_rnd_offset() const; float get_rnd_rotate() const;
void set_rnd_offset(const float val); void set_rnd_rotate(const float val);
float get_rnd_rotate() const; float get_rnd_scale() const;
void set_rnd_rotate(const float val); void set_rnd_scale(const float val);
float get_rnd_scale() const; float get_rnd_opacity() const;
void set_rnd_scale(const float val); void set_rnd_opacity(const float val);
float get_rnd_opacity() const; bool get_variations() const;
void set_rnd_opacity(const float val); void set_variations(const bool val);
bool get_variations() const; void _init_properties();
void set_variations(const bool val); void _register_methods(MMGraphNode *mm_graph_node);
void _render(const Ref<MMMaterial> &material);
Color _get_value_for(const Vector2 &uv, const int pseed);
void _init_properties(); PoolColorArray tiler_calc(const Vector2 &uv, const Vector2 &tile, const int overlap, const Vector2 &_seed);
void _register_methods(const Variant &mm_graph_node);
void _render(const Variant &material);
Color _get_value_for(const Vector2 &uv, const int pseed);
Vector2 get_tile();
void set_tile(const Vector2 &val);
float get_overlap();
void set_overlap(const float val);
int get_select_inputs();
void set_select_inputs(const int val);
Vector2 get_scale();
void set_scale(const Vector2 &val);
float get_fixed_offset();
void set_fixed_offset(const float val);
float get_rnd_offset();
void set_rnd_offset(const float val);
float get_rnd_rotate();
void set_rnd_rotate(const float val);
float get_rnd_scale();
void set_rnd_scale(const float val);
float get_rnd_opacity();
void set_rnd_opacity(const float val);
bool get_variations();
void set_variations(const bool val);
PoolColorArray tiler_calc(const Vector2 &uv, const Vector2 &tile, const int overlap, const Vector2 &_seed);
ColorTiler(); MMColorTiler();
~ColorTiler(); ~MMColorTiler();
protected: protected:
static void _bind_methods(); static void _bind_methods();
//tool Ref<MMNodeUniversalProperty> input;
//export(Resource) Ref<MMNodeUniversalProperty> in_mask;
Ref<Resource> input; Ref<MMNodeUniversalProperty> output;
//export(Resource) Ref<MMNodeUniversalProperty> instance_map;
Ref<Resource> in_mask;
//export(Resource) Vector2 tile = Vector2(4, 4);
Ref<Resource> output; float overlap = 1;
//export(Resource) //export(int, "1,4,16")
Ref<Resource> instance_map; int select_inputs = 0;
//export(Vector2) Vector2 scale = Vector2(0.5, 0.5);
Vector2 tile = Vector2(4, 4); float fixed_offset = 0;
//export(float) float rnd_offset = 0.25;
float overlap = 1; float rnd_rotate = 45;
//export(int, "1,4,16") float rnd_scale = 0.2;
int select_inputs = 0; float rnd_opacity = 0;
//export(Vector2) bool variations = false;
Vector2 scale = Vector2(0.5, 0.5);
//export(float)
float fixed_offset = 0;
//export(float)
float rnd_offset = 0.25;
//export(float)
float rnd_rotate = 45;
//export(float)
float rnd_scale = 0.2;
//export(float)
float rnd_opacity = 0;
//export(bool)
bool variations = false;
//mm_graph_node.add_slot_bool("get_variations", "set_variations", "Variations")
//tile
//overlap
//select_inputs
//scale
//fixed_offset
//rnd_offset
//rnd_rotate
//rnd_scale
//rnd_opacity
//variations
//----------------------
//color_tiler.mmg
//Tiles several occurences of an input image while adding randomness.
//vec4 tiler_$(name)(vec2 uv, vec2 tile, int overlap, vec2 _seed, out vec3 random_color) {
// vec4 c = vec4(0.0);
// vec3 rc = vec3(0.0);
// vec3 rc1;
//
// for (int dx = -overlap; dx <= overlap; ++dx) {
// for (int dy = -overlap; dy <= overlap; ++dy) {
// vec2 pos = fract((floor(uv*tile)+vec2(float(dx), float(dy))+vec2(0.5))/tile-vec2(0.5));
// vec2 seed = rand2(pos+_seed);
// rc1 = rand3(seed);
// pos = fract(pos+vec2($fixed_offset/tile.x, 0.0)*floor(mod(pos.y*tile.y, 2.0))+$offset*seed/tile);
// float mask = $mask(fract(pos+vec2(0.5)));
// if (mask > 0.01) {
// vec2 pv = fract(uv - pos)-vec2(0.5);
// seed = rand2(seed);
// float angle = (seed.x * 2.0 - 1.0) * $rotate * 0.01745329251;
// float ca = cos(angle);
// float sa = sin(angle);
// pv = vec2(ca*pv.x+sa*pv.y, -sa*pv.x+ca*pv.y);
// pv *= (seed.y-0.5)*2.0*$scale+1.0;
// pv /= vec2($scale_x, $scale_y);
// pv += vec2(0.5);
// pv = clamp(pv, vec2(0.0), vec2(1.0));
//
// $select_inputs
//
// vec4 n = $in.variation(pv, $variations ? seed.x : 0.0);
//
// seed = rand2(seed);
// float na = n.a*mask*(1.0-$opacity*seed.x);
// float a = (1.0-c.a)*(1.0*na);
//
// c = mix(c, n, na);
// rc = mix(rc, rc1, n.a);
// }
// }
// }
//
// random_color = rc;
// return c;
//}
//select_inputs enum
//1, " "
//4, "pv = clamp(0.5*(pv+floor(rand2(seed)*2.0)), vec2(0.0), vec2(1.0));"
//16, "pv = clamp(0.25*(pv+floor(rand2(seed)*4.0)), vec2(0.0), vec2(1.0));"
}; };
#endif #endif

196
modules/material_maker/nodes/transform/kaleidoscope.cpp
View File

@ -1,165 +1,105 @@
#include "kaleidoscope.h" #include "kaleidoscope.h"
#include "../../algos/mm_algos.h"
#include "../../editor/mm_graph_node.h"
#include "../mm_material.h"
Ref<Resource> Kaleidoscope::get_image() { Ref<MMNodeUniversalProperty> MMKaleidoscope::get_image() {
return image; return image;
} }
void Kaleidoscope::set_image(const Ref<Resource> &val) { void MMKaleidoscope::set_image(const Ref<MMNodeUniversalProperty> &val) {
image = val; image = val;
} }
Ref<MMNodeUniversalProperty> MMKaleidoscope::get_input() {
Ref<Resource> Kaleidoscope::get_input() { return input;
return input;
} }
void Kaleidoscope::set_input(const Ref<Resource> &val) { void MMKaleidoscope::set_input(const Ref<MMNodeUniversalProperty> &val) {
input = val; input = val;
} }
int MMKaleidoscope::get_count() const {
int Kaleidoscope::get_count() const { return count;
return count;
} }
void Kaleidoscope::set_count(const int val) { void MMKaleidoscope::set_count(const int val) {
count = val; count = val;
set_dirty(true);
} }
float MMKaleidoscope::get_offset() const {
float Kaleidoscope::get_offset() const { return offset;
return offset;
} }
void Kaleidoscope::set_offset(const float val) { void MMKaleidoscope::set_offset(const float val) {
offset = val; offset = val;
set_dirty(true);
} }
void MMKaleidoscope::_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; if (!image.is_valid()) {
//export(Resource) ; image.instance();
Ref<Resource> image; image->set_default_type(MMNodeUniversalProperty::DEFAULT_TYPE_IMAGE);
//export(Resource) ; }
Ref<Resource> input;
//export(int) ;
int count = 5;
//export(float) ;
float offset = 0;
void Kaleidoscope::_init_properties() { //image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT;
image->set_output_slot_type(MMNodeUniversalProperty::SLOT_TYPE_IMAGE);
if (!input) { //image.force_override = true;
input = MMNodeUniversalProperty.new(); register_input_property(input);
input.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_COLOR; register_output_property(image);
input.set_default_value(Color(0, 0, 0, 1));
} }
input.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_UNIVERSAL; void MMKaleidoscope::_register_methods(MMGraphNode *mm_graph_node) {
input.slot_name = ">>> Input "; mm_graph_node->add_slot_label_universal(input);
mm_graph_node->add_slot_texture_universal(image);
if (!image) { mm_graph_node->add_slot_int("get_count", "set_count", "Count");
image = MMNodeUniversalProperty.new(); mm_graph_node->add_slot_float("get_offset", "set_offset", "Offset", 0.5);
image.default_type = MMNodeUniversalProperty.DEFAULT_TYPE_IMAGE;
} }
//image.input_slot_type = MMNodeUniversalProperty.SLOT_TYPE_FLOAT; void MMKaleidoscope::_render(const Ref<MMMaterial> &material) {
image.output_slot_type = MMNodeUniversalProperty.SLOT_TYPE_IMAGE; Ref<Image> img = render_image(material);
//image.force_override = true; image->set_value(img);
register_input_property(input);
register_output_property(image);
} }
Color MMKaleidoscope::_get_value_for(const Vector2 &uv, const int pseed) {
void Kaleidoscope::_register_methods(const Variant &mm_graph_node) { //$i(kal_rotate($uv, $count, $offset));
mm_graph_node.add_slot_label_universal(input); return input->get_value(MMAlgos::kal_rotate(uv, count, offset));
mm_graph_node.add_slot_texture_universal(image);
mm_graph_node.add_slot_int("get_count", "set_count", "Count");
mm_graph_node.add_slot_float("get_offset", "set_offset", "Offset", 0.5);
} }
MMKaleidoscope::MMKaleidoscope() {
void Kaleidoscope::_render(const Variant &material) { count = 5;
Ref<Image> img = render_image(material); offset = 0;
image.set_value(img);
} }
MMKaleidoscope::~MMKaleidoscope() {
Color Kaleidoscope::_get_value_for(const Vector2 &uv, const int pseed) {
//$i(kal_rotate($uv, $count, $offset));
return input.get_value(MMAlgos.kal_rotate(uv, count, offset));
} }
//count; void MMKaleidoscope::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_image"), &MMKaleidoscope::get_image);
ClassDB::bind_method(D_METHOD("set_image", "value"), &MMKaleidoscope::set_image);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref<MMNodeUniversalProperty>"), "set_image", "get_image");
int Kaleidoscope::get_count() { ClassDB::bind_method(D_METHOD("get_input"), &MMKaleidoscope::get_input);
return count; ClassDB::bind_method(D_METHOD("set_input", "value"), &MMKaleidoscope::set_input);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref<MMNodeUniversalProperty>"), "set_input", "get_input");
ClassDB::bind_method(D_METHOD("get_count"), &MMKaleidoscope::get_count);
ClassDB::bind_method(D_METHOD("set_count", "value"), &MMKaleidoscope::set_count);
ADD_PROPERTY(PropertyInfo(Variant::INT, "count"), "set_count", "get_count");
ClassDB::bind_method(D_METHOD("get_offset"), &MMKaleidoscope::get_offset);
ClassDB::bind_method(D_METHOD("set_offset", "value"), &MMKaleidoscope::set_offset);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "offset"), "set_offset", "get_offset");
} }
void Kaleidoscope::set_count(const int val) {
count = val;
set_dirty(true);
}
//offset;
float Kaleidoscope::get_offset() {
return offset;
}
void Kaleidoscope::set_offset(const float val) {
offset = val;
set_dirty(true);
}
}
Kaleidoscope::Kaleidoscope() {
image;
input;
count = 5;
offset = 0;
}
Kaleidoscope::~Kaleidoscope() {
}
static void Kaleidoscope::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_image"), &Kaleidoscope::get_image);
ClassDB::bind_method(D_METHOD("set_image", "value"), &Kaleidoscope::set_image);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "image", PROPERTY_HINT_RESOURCE_TYPE, "Ref<Resource>"), "set_image", "get_image");
ClassDB::bind_method(D_METHOD("get_input"), &Kaleidoscope::get_input);
ClassDB::bind_method(D_METHOD("set_input", "value"), &Kaleidoscope::set_input);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "input", PROPERTY_HINT_RESOURCE_TYPE, "Ref<Resource>"), "set_input", "get_input");
ClassDB::bind_method(D_METHOD("get_count"), &Kaleidoscope::get_count);
ClassDB::bind_method(D_METHOD("set_count", "value"), &Kaleidoscope::set_count);
ADD_PROPERTY(PropertyInfo(Variant::INT, "count"), "set_count", "get_count");
ClassDB::bind_method(D_METHOD("get_offset"), &Kaleidoscope::get_offset);
ClassDB::bind_method(D_METHOD("set_offset", "value"), &Kaleidoscope::set_offset);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "offset"), "set_offset", "get_offset");
ClassDB::bind_method(D_METHOD("_init_properties"), &Kaleidoscope::_init_properties);
ClassDB::bind_method(D_METHOD("_register_methods", "mm_graph_node"), &Kaleidoscope::_register_methods);
ClassDB::bind_method(D_METHOD("_render", "material"), &Kaleidoscope::_render);
ClassDB::bind_method(D_METHOD("_get_value_for", "uv", "pseed"), &Kaleidoscope::_get_value_for);
ClassDB::bind_method(D_METHOD("get_count"), &Kaleidoscope::get_count);
ClassDB::bind_method(D_METHOD("set_count", "val"), &Kaleidoscope::set_count);
ClassDB::bind_method(D_METHOD("get_offset"), &Kaleidoscope::get_offset);
ClassDB::bind_method(D_METHOD("set_offset", "val"), &Kaleidoscope::set_offset);
}

72
modules/material_maker/nodes/transform/kaleidoscope.h
View File

@ -1,51 +1,47 @@
#ifndef KALEIDOSCOPE_H #ifndef MM_KALEIDOSCOPE_H
#define KALEIDOSCOPE_H #define MM_KALEIDOSCOPE_H
#include "../mm_node.h"
#include "../mm_node_universal_property.h"
class Kaleidoscope : public MMNode { class MMKaleidoscope : public MMNode {
GDCLASS(Kaleidoscope, MMNode); GDCLASS(MMKaleidoscope, MMNode);
public: public:
Ref<MMNodeUniversalProperty> get_image();
void set_image(const Ref<MMNodeUniversalProperty> &val);
Ref<Resource> get_image(); Ref<MMNodeUniversalProperty> get_input();
void set_image(const Ref<Resource> &val); void set_input(const Ref<MMNodeUniversalProperty> &val);
Ref<Resource> get_input(); int get_count() const;
void set_input(const Ref<Resource> &val); void set_count(const int val);
int get_count() const; float get_offset() const;
void set_count(const int val); void set_offset(const float val);
float get_offset() const; void _init_properties();
void set_offset(const float val); void _register_methods(MMGraphNode *mm_graph_node);
void _render(const Ref<MMMaterial> &material);
Color _get_value_for(const Vector2 &uv, const int pseed);
void _init_properties(); MMKaleidoscope();
void _register_methods(const Variant &mm_graph_node); ~MMKaleidoscope();
void _render(const Variant &material);
Color _get_value_for(const Vector2 &uv, const int pseed);
int get_count();
void set_count(const int val);
float get_offset();
void set_offset(const float val);
Kaleidoscope(); protected:
~Kaleidoscope(); static void _bind_methods();
protected: //tool
static void _bind_methods(); //export(MMNodeUniversalProperty)
Ref<MMNodeUniversalProperty> image;
//tool //export(MMNodeUniversalProperty)
//export(Resource) Ref<MMNodeUniversalProperty> input;
Ref<Resource> image; //export(int)
//export(Resource) int count = 5;
Ref<Resource> input; //export(float)
//export(int) float offset = 0;
int count = 5; //count
//export(float) //offset
float offset = 0;
//count
//offset
}; };
#endif #endif

9
modules/material_maker/register_types.cpp
View File

@ -45,6 +45,9 @@ SOFTWARE.
#include "nodes/uniform/greyscale_uniform.h" #include "nodes/uniform/greyscale_uniform.h"
#include "nodes/uniform/uniform.h" #include "nodes/uniform/uniform.h"
#include "nodes/transform/circle_map.h"
#include "nodes/transform/color_tiler.h"
#include "nodes/transform/kaleidoscope.h"
#include "nodes/transform/mirror.h" #include "nodes/transform/mirror.h"
#include "nodes/transform/repeat.h" #include "nodes/transform/repeat.h"
#include "nodes/transform/rotate.h" #include "nodes/transform/rotate.h"
@ -91,6 +94,12 @@ void register_material_maker_types() {
MMAlgos::register_node_class("Transform", "MMRepeat"); MMAlgos::register_node_class("Transform", "MMRepeat");
ClassDB::register_class<MMMirror>(); ClassDB::register_class<MMMirror>();
MMAlgos::register_node_class("Transform", "MMMirror"); MMAlgos::register_node_class("Transform", "MMMirror");
ClassDB::register_class<MMKaleidoscope>();
MMAlgos::register_node_class("Transform", "MMKaleidoscope");
ClassDB::register_class<MMColorTiler>();
MMAlgos::register_node_class("Transform", "MMColorTiler");
ClassDB::register_class<MMCircleMap>();
MMAlgos::register_node_class("Transform", "MMCircleMap");
_mm_algos_singleton = memnew(_MMAlgos); _mm_algos_singleton = memnew(_MMAlgos);
Engine::get_singleton()->add_singleton(Engine::Singleton("MMAlgos", _MMAlgos::get_singleton())); Engine::get_singleton()->add_singleton(Engine::Singleton("MMAlgos", _MMAlgos::get_singleton()));