minetest.conf.example

@@ -376,8 +376,10 @@
 # Float islands starts from height, 0 to disable
 #mgindev_float_islands = 500
 
-# Math mapgen generator: sphere, mandelbox, mengersponge      dont forget to lower water_level = -30000
-#mgmath_generator = mandelbox
+# Params for math mapgen in json format. generators supported: sphere, mandelbox, mengersponge, ...      dont forget to lower water_level = -30000
+#mg_math = {"generator":"sphere"}
+#some possible params:
+#mg_math = {"generator":"mengersponge", "size":1000, "distance":0.01, "center":{"x":5,"y":-100,"z":42}, "invert":1, "scale":0.001, "iterations":10}
 
 # Enable/disable IPv6
 #enable_ipv6 = true

src/defaultsettings.cpp

@@ -267,7 +267,7 @@ void set_default_settings(Settings *settings)
 	settings->setDefault("mgindev_np_biome",          "0,    1,   (250, 250, 250), 9130,  3, 0.50, 1,   10");
 	settings->setDefault("mgindev_float_islands", "500");
 
-	settings->setDefault("mgmath_generator", "mandelbox");
+	settings->setDefault("mg_math", ""); // configuration in json struct
 
 	settings->setDefault("curl_timeout", "5000");
 

src/mandelbulber/algebra.cpp

@@ -0,0 +1,213 @@
+/*
+ * algebra.cpp
+ *
+ *  Created on: 2010-02-28
+ *      Author: krzysztof
+ */
+#include "algebra.hpp"
+
+/***************** class CMatrix33 ***********************/
+CMatrix33::CMatrix33()
+{
+	m11 = 0;
+	m12 = 0;
+	m13 = 0;
+	m21 = 0;
+	m22 = 0;
+	m23 = 0;
+	m31 = 0;
+	m32 = 0;
+	m33 = 0;
+}
+
+CMatrix33::CMatrix33(const CMatrix33 &matrix)
+{
+	m11 = matrix.m11;
+	m12 = matrix.m12;
+	m13 = matrix.m13;
+	m21 = matrix.m21;
+	m22 = matrix.m22;
+	m23 = matrix.m23;
+	m31 = matrix.m31;
+	m32 = matrix.m32;
+	m33 = matrix.m33;
+}
+
+CMatrix33& CMatrix33::operator=(const CMatrix33 &matrix)
+{
+	m11 = matrix.m11;
+	m12 = matrix.m12;
+	m13 = matrix.m13;
+	m21 = matrix.m21;
+	m22 = matrix.m22;
+	m23 = matrix.m23;
+	m31 = matrix.m31;
+	m32 = matrix.m32;
+	m33 = matrix.m33;
+	return *this;
+}
+
+CMatrix33 CMatrix33::operator*(const CMatrix33 &matrix) const
+{
+	CMatrix33 result;
+	result.m11 = m11 * matrix.m11 + m12 * matrix.m21 + m13 * matrix.m31;
+	result.m12 = m11 * matrix.m12 + m12 * matrix.m22 + m13 * matrix.m32;
+	result.m13 = m11 * matrix.m13 + m12 * matrix.m23 + m13 * matrix.m33;
+	result.m21 = m21 * matrix.m11 + m22 * matrix.m21 + m23 * matrix.m31;
+	result.m22 = m21 * matrix.m12 + m22 * matrix.m22 + m23 * matrix.m32;
+	result.m23 = m21 * matrix.m13 + m22 * matrix.m23 + m23 * matrix.m33;
+	result.m31 = m31 * matrix.m11 + m32 * matrix.m21 + m33 * matrix.m31;
+	result.m32 = m31 * matrix.m12 + m32 * matrix.m22 + m33 * matrix.m32;
+	result.m33 = m31 * matrix.m13 + m32 * matrix.m23 + m33 * matrix.m33;
+	return result;
+}
+
+CVector3 CMatrix33::operator*(const CVector3 &vector) const
+{
+	CVector3 result;
+	result.x = m11 * vector.x + m12 * vector.y + m13 * vector.z;
+	result.y = m21 * vector.x + m22 * vector.y + m23 * vector.z;
+	result.z = m31 * vector.x + m32 * vector.y + m33 * vector.z;
+	return result;
+}
+
+/**************** class RotarionMatrix **********************/
+CRotationMatrix::CRotationMatrix()
+{
+	matrix.m11 = 1.0;
+	matrix.m12 = 0.0;
+	matrix.m13 = 0.0;
+	matrix.m21 = 0.0;
+	matrix.m22 = 1.0;
+	matrix.m23 = 0.0;
+	matrix.m31 = 0.0;
+	matrix.m32 = 0.0;
+	matrix.m33 = 1.0;
+	zero = true;
+}
+
+void CRotationMatrix::RotateX(double angle)
+{
+	if (angle != 0.0)
+	{
+		CMatrix33 rot;
+		double s = sin(angle);
+		double c = cos(angle);
+		rot.m11 = 1.0;
+		rot.m22 = c;
+		rot.m33 = c;
+		rot.m23 = -s;
+		rot.m32 = s;
+		matrix = matrix * rot;
+		zero = false;
+	}
+}
+
+void CRotationMatrix::RotateY(double angle)
+{
+	if (angle != 0.0)
+	{
+		CMatrix33 rot;
+		double s = sin(angle);
+		double c = cos(angle);
+		rot.m22 = 1.0;
+		rot.m33 = c;
+		rot.m11 = c;
+		rot.m31 = -s;
+		rot.m13 = s;
+		matrix = matrix * rot;
+		zero = false;
+	}
+}
+
+void CRotationMatrix::RotateZ(double angle)
+{
+	if (angle != 0.0)
+	{
+		CMatrix33 rot;
+		double s = sin(angle);
+		double c = cos(angle);
+		rot.m33 = 1.0;
+		rot.m11 = c;
+		rot.m22 = c;
+		rot.m12 = -s;
+		rot.m21 = s;
+		matrix = matrix * rot;
+		zero = false;
+	}
+}
+
+void CRotationMatrix::SetRotation(double angles[3])
+{
+	Null();
+	RotateZ(angles[2]);
+	RotateY(angles[1]);
+	RotateX(angles[0]);
+}
+
+void CRotationMatrix::SetRotation(double alfa, double beta, double gamma)
+{
+	Null();
+	RotateZ(alfa);
+	RotateY(beta);
+	RotateX(gamma);
+}
+
+CVector3 CRotationMatrix::RotateVector(const CVector3& vector) const
+{
+	if (!zero)
+	{
+		CVector3 vector2 = matrix * vector;
+		return vector2;
+	}
+	else
+	{
+		return vector;
+	}
+}
+
+void CRotationMatrix::Null()
+{
+	//CRotationMatrix();
+	matrix.m11 = 1.0;
+	matrix.m12 = 0.0;
+	matrix.m13 = 0.0;
+	matrix.m21 = 0.0;
+	matrix.m22 = 1.0;
+	matrix.m23 = 0.0;
+	matrix.m31 = 0.0;
+	matrix.m32 = 0.0;
+	matrix.m33 = 1.0;
+	zero = true;
+}
+
+double CRotationMatrix::GetAlfa() const
+{
+	return atan2(matrix.m12,matrix.m22);
+}
+
+double CRotationMatrix::GetBeta() const
+{
+	return asin(-matrix.m32);
+}
+
+double CRotationMatrix::GetGamma() const
+{
+	return atan2(matrix.m31,matrix.m33);
+}
+
+CRotationMatrix CRotationMatrix::Transpose() const
+{
+	CRotationMatrix m;
+	m.matrix.m11 = matrix.m11;
+	m.matrix.m12 = matrix.m21;
+	m.matrix.m13 = matrix.m31;
+	m.matrix.m21 = matrix.m12;
+	m.matrix.m22 = matrix.m22;
+	m.matrix.m23 = matrix.m32;
+	m.matrix.m31 = matrix.m13;
+	m.matrix.m32 = matrix.m23;
+	m.matrix.m33 = matrix.m33;
+	m.zero = false;
+	return m;
+}

src/mandelbulber/algebra.hpp

@@ -0,0 +1,161 @@
+/********************************************************
+ /                   3D math                             *
+ /                                                       *
+ / author: Krzysztof Marczak                             *
+ / contact: buddhi1980@gmail.com                         *
+ / licence: GNU GPL                                      *
+ ********************************************************/
+
+#ifndef ALGEBRA_H_
+#define ALGEBRA_H_
+
+#include <math.h>
+
+/************************* vector 3D **********************/
+class CVector3
+{
+public:
+	inline CVector3()
+	{
+		x = 0;
+		y = 0;
+		z = 0;
+	}
+	inline CVector3(double x_init, double y_init, double z_init)
+	{
+		x = x_init;
+		y = y_init;
+		z = z_init;
+	}
+	inline CVector3(double alfa, double beta)
+	{
+		x = cos(beta) * cos(alfa);
+		y = cos(beta) * sin(alfa);
+		z = sin(beta);
+	}
+	inline CVector3(const CVector3 &vector)
+	{
+		x = vector.x;
+		y = vector.y;
+		z = vector.z;
+	}
+	inline CVector3 operator+(const CVector3 &vector) const
+	{
+		return CVector3(x + vector.x, y + vector.y, z + vector.z);
+	}
+	inline CVector3 operator-(const CVector3 &vector) const
+	{
+		return CVector3(x - vector.x, y - vector.y, z - vector.z);
+	}
+	inline CVector3 operator*(const double &scalar) const
+	{
+		return CVector3(x * scalar, y * scalar, z * scalar);
+	}
+	inline CVector3& operator=(const CVector3 &vector)
+	{
+		x = vector.x;
+		y = vector.y;
+		z = vector.z;
+		return *this;
+	}
+	inline CVector3& operator+=(const CVector3 &vector)
+	{
+		x += vector.x;
+		y += vector.y;
+		z += vector.z;
+		return *this;
+	}
+	inline CVector3& operator-=(const CVector3 &vector)
+	{
+		x -= vector.x;
+		y -= vector.y;
+		z -= vector.z;
+		return *this;
+	}
+	inline CVector3& operator*=(const double &scalar)
+	{
+		x *= scalar;
+		y *= scalar;
+		z *= scalar;
+		return *this;
+	}
+	inline double Length() const
+	{
+		return sqrt(x * x + y * y + z * z);
+	}
+	inline double Dot(const CVector3& vector) const
+	{
+		return x * vector.x + y * vector.y + z * vector.z;
+	}
+	inline CVector3 Cross(const CVector3& v)
+	{
+		CVector3 c;
+		c.x =  y*v.z - z*v.y;
+	  c.y = -x*v.z + z*v.x;
+	  c.z =  x*v.y - y*v.x;
+	  return c;
+	}
+	inline double Normalize() //returns normalization factor
+	{
+		double norm = 1.0 / Length();
+		x = x * norm;
+		y = y * norm;
+		z = z * norm;
+		return norm;
+	}
+	inline double GetAlfa() const
+	{
+		return atan2(y, x);
+	}
+	inline double GetBeta() const
+	{
+		return atan2(z, sqrt(x * x + y * y));
+	}
+	double x;
+	double y;
+	double z;
+};
+
+/************************* matrix 3x3 (fast) *****************/
+class CMatrix33
+{
+public:
+	CMatrix33();
+	CMatrix33(const CMatrix33 &matrix);
+	CMatrix33 operator*(const CMatrix33 &matrix) const;
+	CVector3 operator*(const CVector3 &vector) const;
+	CMatrix33& operator=(const CMatrix33&);
+	double m11;
+	double m12;
+	double m13;
+	double m21;
+	double m22;
+	double m23;
+	double m31;
+	double m32;
+	double m33;
+};
+
+/************************* rotation matrix *******************/
+class CRotationMatrix
+{
+public:
+	CRotationMatrix();
+	void RotateX(double angle);
+	void RotateY(double angle);
+	void RotateZ(double angle);
+	void Null();
+	CVector3 RotateVector(const CVector3& vector) const;
+	double GetAlfa() const;
+	double GetBeta() const;
+	double GetGamma() const;
+	void SetRotation(double angles[3]);
+	void SetRotation(double alfa, double beta, double gamma);
+	CRotationMatrix Transpose(void) const;
+	CMatrix33 GetMatrix() {return matrix;}
+private:
+	CMatrix33 matrix;
+	bool zero;
+};
+
+#endif /* ALGEBRA_H_ */