pandemonium_engine/modules/material_maker/nodes/bases/curve_base.cpp

#include "curve_base.h"

Vector2 CurveBase::Point::get_p() {
	return p;
}

void CurveBase::Point::set_p(const Vector2 &val) {
	p = val;
}

float CurveBase::Point::get_ls() const {
	return ls;
}

void CurveBase::Point::set_ls(const float val) {
	ls = val;
}

float CurveBase::Point::get_rs() const {
	return rs;
}

void CurveBase::Point::set_rs(const float val) {
	rs = val;
}

CurveBase::Point::Point() {
	ls = 0;
	rs = 0;
}

CurveBase::Point::Point(const float x, const float y, const float nls, const float nrs) {
	p = Vector2(x, y);
	ls = nls;
	rs = nrs;
}

CurveBase::Point::~Point() {
}

void CurveBase::Point::_bind_methods() {
	ClassDB::bind_method(D_METHOD("get_p"), &CurveBase::Point::get_p);
	ClassDB::bind_method(D_METHOD("set_p", "value"), &CurveBase::Point::set_p);
	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "p"), "set_p", "get_p");

	ClassDB::bind_method(D_METHOD("get_ls"), &CurveBase::Point::get_ls);
	ClassDB::bind_method(D_METHOD("set_ls", "value"), &CurveBase::Point::set_ls);
	ADD_PROPERTY(PropertyInfo(Variant::REAL, "ls"), "set_ls", "get_ls");

	ClassDB::bind_method(D_METHOD("get_rs"), &CurveBase::Point::get_rs);
	ClassDB::bind_method(D_METHOD("set_rs", "value"), &CurveBase::Point::set_rs);
	ADD_PROPERTY(PropertyInfo(Variant::REAL, "rs"), "set_rs", "get_rs");
}

PoolRealArray CurveBase::get_points() {
	return points;
}

void CurveBase::set_points(const PoolRealArray &val) {
	points = val;
}

void CurveBase::init_points_01() {
	if (points.size() == 0) {
		points = [ 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0 ];
	}
}

void CurveBase::init_points_11() {
	if (points.size() == 0) {
		points = [ 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0 ];
	}
}

String CurveBase::to_string() {
	PoolStringArray rv;

	for (p in points) {
		rv.append("(" + str(p.x) + "," + str(p.y) + "," + str(p.ls) + "," + str(p.rs) + ")");
	}

	return rv.join(",");
}

void CurveBase::clear() {
	points.clear();
	curve_changed();
}

void CurveBase::add_point(const float x, const float y, const float ls, const float rs) {
	int indx = points.size() / 4;

	for (i in indx) {
		int ii = i * 4;

		if (x < points[ii]) {
			if (ls == INF) {
				ls == 0;
			}

			if (rs == INF) {
				rs == 0;
			}

			points.insert(ii, x);
			points.insert(ii + 1, y);
			points.insert(ii + 2, ls);
			points.insert(ii + 3, rs);
			curve_changed();
			return;
		}
	}

	points.append(x);
	points.append(y);
	points.append(ls);
	points.append(rs);
	curve_changed();
}

bool CurveBase::remove_point(const int i) {
	int index = i * 4;

	if (index <= 0 || index >= points.size() - 1) {
		return false;
	} else {
		points.remove(index);
		points.remove(index);
		points.remove(index);
		points.remove(index);
		curve_changed();
	}

	return true;
}

int CurveBase::get_point_count() {
	return points.size() / 4;
}

void CurveBase::set_point(const int i, const Point &v) {
	int indx = i * 4;
	points[indx + 0] = v.p.x;
	points[indx + 1] = v.p.y;
	points[indx + 2] = v.ls;
	points[indx + 3] = v.rs;
	curve_changed();
}

Point CurveBase::get_point(const int i) {
	int indx = i * 4;
	return Point.new(points[indx + 0], points[indx + 1], points[indx + 2], points[indx + 3]);
}

Array CurveBase::get_points() {
	Array arr = Array();
	int c = get_point_count();

	for (int i = 0; i < c; ++i) { //i in range(c)
		arr.append(get_point(i));
	}

	return arr;
}

void CurveBase::set_points(const Array &arr, const bool notify) {
	points.resize(0);

	for (p in arr) {
		points.append(p.p.x);
		points.append(p.p.y);
		points.append(p.ls);
		points.append(p.rs);
	}

	if (notify) {
		curve_changed();
	}
}

void CurveBase::curve_changed() {
	_curve_changed();
}

void CurveBase::_curve_changed() {
	emit_changed();
}

CurveBase::CurveBase() {
}

CurveBase::~CurveBase() {
}

static void CurveBase::_bind_methods() {
	ClassDB::bind_method(D_METHOD("get_Variant"), &CurveBase::get_Variant);
	ClassDB::bind_method(D_METHOD("set_Variant", "value"), &CurveBase::set_Variant);
	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "Variant", PROPERTY_HINT_RESOURCE_TYPE, "Variant"), "set_Variant", "get_Variant");

	ClassDB::bind_method(D_METHOD("init_points_01"), &CurveBase::init_points_01);
	ClassDB::bind_method(D_METHOD("init_points_11"), &CurveBase::init_points_11);

	ClassDB::bind_method(D_METHOD("to_string"), &CurveBase::to_string);

	ClassDB::bind_method(D_METHOD("clear"), &CurveBase::clear);

	ClassDB::bind_method(D_METHOD("add_point", "x", "y", "ls", "rs"), &CurveBase::add_point, INF, INF);
	ClassDB::bind_method(D_METHOD("remove_point", "i"), &CurveBase::remove_point);

	ClassDB::bind_method(D_METHOD("get_point_count"), &CurveBase::get_point_count);

	ClassDB::bind_method(D_METHOD("set_point", "i", "v"), &CurveBase::set_point);
	ClassDB::bind_method(D_METHOD("get_point", "i"), &CurveBase::get_point);

	ClassDB::bind_method(D_METHOD("get_points"), &CurveBase::get_points);
	ClassDB::bind_method(D_METHOD("set_points", "arr", "notify"), &CurveBase::set_points, true);

	ClassDB::bind_method(D_METHOD("curve_changed"), &CurveBase::curve_changed);
	ClassDB::bind_method(D_METHOD("_curve_changed"), &CurveBase::_curve_changed);
}