3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU Lesser General Public License as published by
7 the Free Software Foundation; either version 2.1 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public License along
16 with this program; if not, write to the Free Software Foundation, Inc.,
17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 #include "mapgen_math.h"
27 #include "voxelalgorithms.h"
29 #include "settings.h" // For g_settings
30 #include "main.h" // For g_profiler
34 // can use ported lib from http://mandelbulber.googlecode.com/svn/trunk/src
35 //#include "mandelbulber/fractal.h"
36 //#include "mandelbulber/fractal.cpp"
38 double mandelbox(double x, double y, double z, double d, int nn = 10) {
54 double minRadius2 = 0.25;
55 double fixedRadius2 = 1;
57 for (int n = 0; n < nn; n++) {
73 double r2 = x * x + y * y + z * z;
75 if (r2 < minRadius2) {
76 x = x * fixedRadius2 / minRadius2;
77 y = y * fixedRadius2 / minRadius2;
78 z = z * fixedRadius2 / minRadius2;
79 dr = dr * fixedRadius2 / minRadius2;
80 } else if (r2 < fixedRadius2) {
81 x = x * fixedRadius2 / r2;
82 y = y * fixedRadius2 / r2;
83 z = z * fixedRadius2 / r2;
84 fixedRadius2 *= fixedRadius2 / r2;
92 r = sqrt(x * x + y * y + z * z);
93 return ((r / fabs(dr)) < d);
97 double mengersponge(double x, double y, double z, double d, int MI = 10) {
99 double r = x * x + y * y + z * z;
104 for (i = 0; i < MI && r < 9; i++) {
129 x = scale * x - 1 * (scale - 1);
130 y = scale * y - 1 * (scale - 1);
134 if (z > 0.5 * 1 * (scale - 1))
135 z -= 1 * (scale - 1);
138 r = x * x + y * y + z * z;
140 return ((sqrt(r)) * pow(scale, (-i)) < d);
143 double sphere(double x, double y, double z, double d, int ITR = 1) {
144 return v3f(x, y, z).getLength() < d;
148 //////////////////////// Mapgen Math parameter read/write
150 void MapgenMathParams::readParams(Settings *settings) {
151 //params = settings->getJson("mg_math");
152 // can be counfigured from here.
153 std::string value = "{}";
155 if (!reader.parse( value, params ) ) {
156 errorstream << "Failed to parse json conf var ='" << value << "' : " << reader.getFormattedErrorMessages();
159 if (params["generator"].empty()) params["generator"] = settings->get("mgmath_generator");
163 void MapgenMathParams::writeParams(Settings *settings) {
164 //settings->setJson("mg_math", params);
165 settings->set("mgmath_generator", params["generator"].asString());
168 ///////////////////////////////////////////////////////////////////////////////
170 MapgenMath::MapgenMath(int mapgenid, MapgenParams *params_, EmergeManager *emerge) : MapgenV7(mapgenid, params_, emerge) {
171 mg_params = (MapgenMathParams *)params_;
172 this->flags &= ~MG_LIGHT;
174 Json::Value & params = mg_params->params;
175 invert = params["invert"].empty() ? 1 : params["invert"].asBool(); //params["invert"].empty()?1:params["invert"].asBool();
176 size = params["size"].empty() ? 0 : params["size"].asDouble(); // = max_r
177 scale = params["scale"].empty() ? 0 : params["scale"].asDouble(); //(double)1 / size;
178 if(!params["center"].empty()) center = v3f(params["center"]["x"].asFloat(), params["center"]["y"].asFloat(), params["center"]["z"].asFloat()); //v3f(5, -size - 5, 5);
179 iterations = params["iterations"].empty() ? 0 : params["iterations"].asInt(); //10;
180 distance = params["distance"].empty() ? 0 : params["distance"].asDouble(); // = 1/size;
184 if (params["generator"].empty()) params["generator"] = "mandelbox";
185 if (params["generator"].asString() == "mengersponge") {
186 if (!size) size = (MAP_GENERATION_LIMIT - 1000) / 2;
187 if (!iterations) iterations = 10;
188 if (!distance) distance = 0.0003;
189 //if (!scale) scale = (double)0.1 / size;
190 //if (!distance) distance = 0.01; //10/size;//sqrt3 * bd4;
191 //if (!scale) scale = 0.01; //10/size;//sqrt3 * bd4;
192 //center=v3f(-size/3,-size/3+(-2*-invert),2);
193 center = v3f(-size, -size, -size);
194 func = &mengersponge;
195 } else if (params["generator"].asString() == "mandelbox") {
197 size = MAP_GENERATION_LIMIT - 1000;
199 distance = 0.01; //100/size; //0.01;
201 center = v3f(1, 1, 1); // *size/6;
205 if (!size) size = 1000;
206 if (!distance) distance = 0.01;
207 if(params["invert"].empty()) invert = 0;
208 //center=v3f(2,-size/4,2);
210 //center=v3f(size/2,-size*0.9,size/2);
211 if(params["center"].empty())center = v3f(size * 0.3, -size * 0.6, size * 0.5);
213 } else if (params["generator"].asString() == "sphere") {
214 if(params["invert"].empty()) invert = 0;
215 if (!size) size = 100;
216 if (!distance) distance = size;
218 if (!scale) scale = 1;
220 //size = 1000;scale = 1;center = v3f(2,-size-2,2);
223 if (!iterations) iterations = 10;
224 if (!size) size = 1000;
225 if (!scale) scale = (double)1 / size;
226 if (!distance) distance = scale;
227 if (params["center"].empty() && !center.getLength()) center = v3f(3, -size + (-5 - (-invert * 10)), 3);
228 //size ||= params["size"].empty()?1000:params["size"].asDouble(); // = max_r
233 MapgenMath::~MapgenMath() {
236 //////////////////////// Map generator
238 int MapgenMath::generateTerrain() {
240 MapNode n_air(CONTENT_AIR, LIGHT_SUN), n_water_source(c_water_source, LIGHT_SUN);
241 MapNode n_stone(c_stone, LIGHT_SUN);
243 v3s16 em = vm->m_area.getExtent();
248 v3f vec0 = (v3f(node_min.X, node_min.Y, node_min.Z) - center) * scale ;
249 errorstream << " X=" << node_min.X << " Y=" << node_min.Y << " Z=" << node_min.Z
250 //<< " N="<< mengersponge(vec0.X, vec0.Y, vec0.Z, distance, iterations)
251 << " N=" << (*func)(vec0.X, vec0.Y, vec0.Z, distance, iterations)
252 << " Sc=" << scale << " gen=" << params["generator"].asString() << " J=" << Json::FastWriter().write(params) << std::endl;
254 for (s16 z = node_min.Z; z <= node_max.Z; z++) {
255 for (s16 x = node_min.X; x <= node_max.X; x++, index++) {
256 //Biome *biome = bmgr->biomes[biomemap[index]];
257 u32 i = vm->m_area.index(x, node_min.Y, z);
258 for (s16 y = node_min.Y; y <= node_max.Y; y++) {
259 v3f vec = (v3f(x, y, z) - center) * scale ;
260 double d = (*func)(vec.X, vec.Y, vec.Z, distance, iterations);
261 if ((!invert && d > 0) || (invert && d == 0) ) {
262 if (vm->m_data[i].getContent() == CONTENT_IGNORE)
263 // vm->m_data[i] = (y > water_level + biome->filler) ?
264 // MapNode(biome->c_filler) : n_stone;
265 vm->m_data[i] = n_stone;
266 } else if (y <= water_level) {
267 vm->m_data[i] = n_water_source;
269 vm->m_data[i] = n_air;
271 vm->m_area.add_y(em, i, 1);
279 // mandelbulber, unfinished but works
283 par.doubles.power = 9.0;
284 par.doubles.foldingSphericalFixed = 1.0;
285 par.doubles.foldingSphericalMin = 0.5;
286 //no par.formula = smoothMandelbox; par.doubles.N = 40; invert = 0;//no
287 par.mandelbox.doubles.sharpness = 3.0;
288 par.mandelbox.doubles.scale = 1;
289 par.mandelbox.doubles.sharpness = 2;
290 par.mandelbox.doubles.foldingLimit = 1.0;
291 par.mandelbox.doubles.foldingValue = 2;
293 //ok par.formula = mandelboxVaryScale4D; par.doubles.N = 50; scale = 5; invert = 1; //ok
294 par.mandelbox.doubles.vary4D.scaleVary = 0.1;
295 par.mandelbox.doubles.vary4D.fold = 1;
296 par.mandelbox.doubles.vary4D.rPower = 1;
297 par.mandelbox.doubles.vary4D.minR = 0.5;
298 par.mandelbox.doubles.vary4D.wadd = 0;
299 par.doubles.constantFactor = 1.0;
301 par.formula = menger_sponge; par.doubles.N = 15; invert = 0; size = 30000; center = v3f(-size / 2, -size + (-2 * -invert), 2); scale = (double)1 / size; //ok
303 //double tresh = 1.5;
304 //par.formula = mandelbulb2; par.doubles.N = 10; scale = (double)1/size; invert=1; center = v3f(5,-size-5,0); //ok
305 //par.formula = hypercomplex; par.doubles.N = 20; scale = 0.0001; invert=1; center = v3f(0,-10001,0); //(double)50 / max_r;
307 //no par.formula = trig_DE; par.doubles.N = 5; scale = (double)10; invert=1;
309 //no par.formula = trig_optim; scale = (double)10; par.doubles.N = 4;
311 //par.formula = mandelbulb2; scale = (double)1/10000; par.doubles.N = 10; invert = 1; center = v3f(1,-4201,1); //ok
312 // no par.formula = tglad;
314 //par.formula = xenodreambuie; par.juliaMode = 1; par.doubles.julia.x = -1; par.doubles.power = 2.0; center=v3f(-size/2,-size/2-5,5); //ok
316 par.mandelbox.doubles.vary4D.scaleVary = 0.1;
317 par.mandelbox.doubles.vary4D.fold = 1;
318 par.mandelbox.doubles.vary4D.minR = 0.5;
319 par.mandelbox.doubles.vary4D.rPower = 1;
320 par.mandelbox.doubles.vary4D.wadd = 0;
321 //no par.formula = mandelboxVaryScale4D;
322 par.doubles.cadd = -1.3;
323 //par.formula = aexion; // ok but center
324 //par.formula = benesi; par.doubles.N = 10; center = v3f(0,0,0); invert = 0; //ok
326 // par.formula = bristorbrot; //ok
328 v3f vec0(node_min.X, node_min.Y, node_min.Z);
329 vec0 = (vec0 - center) * scale ;
330 errorstream << " X=" << node_min.X << " Y=" << node_min.Y << " Z=" << node_min.Z
331 << " N=" << Compute<normal>(CVector3(vec0.X, vec0.Y, vec0.Z), par)
332 //<<" F="<< Compute<fake_AO>(CVector3(node_min.X,node_min.Y,node_min.Z), par)
333 //<<" L="<<node_min.getLength()<< " -="<<node_min.getLength() - Compute<normal>(CVector3(node_min.X,node_min.Y,node_min.Z), par)
337 for (s16 z = node_min.Z; z <= node_max.Z; z++)
338 for (s16 y = node_min.Y; y <= node_max.Y; y++) {
339 u32 i = vm->m_area.index(node_min.X, y, z);
340 for (s16 x = node_min.X; x <= node_max.X; x++) {
342 vec = (vec - center) * scale ;
343 //double d = Compute<fake_AO>(CVector3(x,y,z), par);
344 double d = Compute<normal>(CVector3(vec.X, vec.Y, vec.Z), par);
346 // errorstream << " d=" << d <<" v="<< vec.getLength()<< " -="<< vec.getLength() - d <<" yad="
347 //<< Compute<normal>(CVector3(x,y,z), par)
349 if ((!invert && d > 0) || (invert && d == 0)/*&& vec.getLength() - d > tresh*/ ) {
350 if (vm->m_data[i].getContent() == CONTENT_IGNORE)
351 vm->m_data[i] = n_stone;
353 vm->m_data[i] = n_air;
364 int MapgenMath::getGroundLevelAtPoint(v2s16 p) {