Added screenshot in README

At chunkgen init, build a list of the polygons instead of calculating them for every node.

.gitignore

@@ -1,10 +1,9 @@
 __pycache__/
 dem
 lakes
+links
+rivers
 size
 offset_x
 offset_y
-bounds_x
-bounds_y
-rivers
 unused/

init.lua

@@ -24,22 +24,22 @@ local X = tonumber(sfile:read('*l'))
 local Z = tonumber(sfile:read('*l'))
 
 copy_if_needed('dem')
-local dem = load_map(worldpath..'dem', 2, true, X*Z)
+local dem = load_map(worldpath..'dem', 2, true)
 copy_if_needed('lakes')
-local lakes = load_map(worldpath..'lakes', 2, true, X*Z)
+local lakes = load_map(worldpath..'lakes', 2, true)
-copy_if_needed('bounds_x')
+copy_if_needed('links')
-local bounds_x = load_map(worldpath..'bounds_x', 4, false, (X-1)*Z)
+local links = load_map(worldpath..'links', 1, false)
-copy_if_needed('bounds_y')
+copy_if_needed('rivers')
-local bounds_z = load_map(worldpath..'bounds_y', 4, false, X*(Z-1))
+local rivers = load_map(worldpath..'rivers', 4, false)
 
 copy_if_needed('offset_x')
-local offset_x = load_map(worldpath..'offset_x', 1, true, X*Z)
+local offset_x = load_map(worldpath..'offset_x', 1, true)
 for k, v in ipairs(offset_x) do
 	offset_x[k] = (v+0.5)/256
 end
 
 copy_if_needed('offset_y')
-local offset_z = load_map(worldpath..'offset_y', 1, true, X*Z)
+local offset_z = load_map(worldpath..'offset_y', 1, true)
 for k, v in ipairs(offset_z) do
 	offset_z[k] = (v+0.5)/256
 end
@@ -54,7 +54,7 @@ local function get_point_location(x, z)
 	return x+offset_x[i], z+offset_z[i]
 end
 
-local function interp(v00, v01, v11, v10, xf, zf)
+local function interp(v00, v01, v10, v11, xf, zf)
 	local v0 = v01*xf + v00*(1-xf)
 	local v1 = v11*xf + v10*(1-xf)
 	return v1*zf + v0*(1-zf)
@@ -65,29 +65,22 @@ local data = {}
 local blocksize = 12
 local sea_level = 1
 local min_catchment = 25
-local max_catchment = 40000
-local riverbed_slope = 0.4
 
-local get_settings = dofile(modpath .. 'settings.lua')
+local storage = minetest.get_mod_storage()
-
+if storage:contains("blocksize") then
-blocksize = get_settings('blocksize', 'int', blocksize)
+	blocksize = storage:get_int("blocksize")
-sea_level = get_settings('sea_level', 'int', sea_level)
+else
-min_catchment = get_settings('min_catchment', 'float', min_catchment)
+	storage:set_int("blocksize", blocksize)
-max_catchment = get_settings('max_catchment', 'float', max_catchment)
-riverbed_slope = get_settings('riverbed_slope', 'float', riverbed_slope) * blocksize
-
--- Width coefficients: coefficients solving
---   wfactor * min_catchment ^ wpower = 1/(2*blocksize)
---   wfactor * max_catchment ^ wpower = 1
-local wpower = math.log(2*blocksize)/math.log(max_catchment/min_catchment)
-local wfactor = 1 / max_catchment ^ wpower
-local function river_width(flow)
-	flow = math.abs(flow)
-	if flow < min_catchment then
-		return 0
 end
-
+if storage:contains("sea_level") then
-	return math.min(wfactor * flow ^ wpower, 1)
+	sea_level = storage:get_int("sea_level")
+else
+	storage:set_int("sea_level", sea_level)
+end
+if storage:contains("min_catchment") then
+	min_catchment = storage:get_float("min_catchment")
+else
+	storage:set_float("min_catchment", min_catchment)
 end
 
 local function generate(minp, maxp, seed)
@@ -105,10 +98,12 @@ local function generate(minp, maxp, seed)
 	local ystride = a.ystride -- Tip : the ystride of a VoxelArea is the number to add to the array index to get the index of the position above. It's faster because it avoids to completely recalculate the index.
 	local chulens = maxp.z - minp.z + 1
 
+	local polygon_number = {}
 	local polygons = {}
 	local xpmin, xpmax = math.max(math.floor(minp.x/blocksize - 0.5), 0), math.min(math.ceil(maxp.x/blocksize), X-2)
 	local zpmin, zpmax = math.max(math.floor(minp.z/blocksize - 0.5), 0), math.min(math.ceil(maxp.z/blocksize), Z-2)
-
+	local n = 1
+	local n_filled = 0
 	for xp = xpmin, xpmax do
 		for zp=zpmin, zpmax do
 			local iA = index(xp, zp)
@@ -117,7 +112,6 @@ local function generate(minp, maxp, seed)
 			local iD = index(xp, zp+1)
 			local poly_x = {offset_x[iA]+xp, offset_x[iB]+xp+1, offset_x[iC]+xp+1, offset_x[iD]+xp}
 			local poly_z = {offset_z[iA]+zp, offset_z[iB]+zp, offset_z[iC]+zp+1, offset_z[iD]+zp+1}
-			local polygon = {x=poly_x, z=poly_z, i={iA, iB, iC, iD}}
 
 			local bounds = {}
 			local xmin = math.max(math.floor(blocksize*math.min(unpack(poly_x)))+1, minp.x)
@@ -150,128 +144,73 @@ local function generate(minp, maxp, seed)
 					local zmax = math.min(math.floor(xlist[l*2]), maxp.z)
 					local i = (x-minp.x) * chulens + (zmin-minp.z) + 1
 					for z=zmin, zmax do
-						polygons[i] = polygon
+						polygon_number[i] = n
 						i = i + 1
+						n_filled = n_filled + 1
 					end
 				end
 			end
 
-			polygon.dem = {dem[iA], dem[iB], dem[iC], dem[iD]}
+			polygons[n] = {x=poly_x, z=poly_z, i={iA, iB, iC, iD}}
-			polygon.lake = math.min(lakes[iA], lakes[iB], lakes[iC], lakes[iD])
+			n = n + 1
-
-			local river_west = river_width(bounds_z[iA])
-			local river_north = river_width(bounds_x[iA-zp])
-			local river_east = 1-river_width(bounds_z[iB])
-			local river_south = 1-river_width(bounds_x[iD-zp-1])
-			if river_west > river_east then
-				local mean = (river_west + river_east) / 2
-				river_west = mean
-				river_east = mean
-			end
-			if river_north > river_south then
-				local mean = (river_north + river_south) / 2
-				river_north = mean
-				river_south = mean
-			end
-			polygon.rivers = {river_west, river_north, river_east, river_south}
-
-			local around = {0,0,0,0,0,0,0,0}
-			if zp > 0 then
-				around[1] = river_width(bounds_z[iA-X])
-				around[2] = river_width(bounds_z[iB-X])
-			end
-			if xp < X-2 then
-				around[3] = river_width(bounds_x[iB-zp])
-				around[4] = river_width(bounds_x[iC-zp-1])
-			end
-			if zp < Z-2 then
-				around[5] = river_width(bounds_z[iC])
-				around[6] = river_width(bounds_z[iD])
-			end
-			if xp > 0 then
-				around[7] = river_width(bounds_x[iD-zp-2])
-				around[8] = river_width(bounds_x[iA-zp-1])
-			end
-			polygon.river_corners = {math.max(around[8], around[1]), math.max(around[2], around[3]), math.max(around[4], around[5]), math.max(around[6], around[7])}
 		end
 	end
 
 	local i = 1
 	for x = minp.x, maxp.x do
 		for z = minp.z, maxp.z do
-			local poly = polygons[i]
+			local npoly = polygon_number[i]
-			if poly then
+			if npoly then
+				local poly = polygons[npoly]
 				local xf, zf = geometry.transform_quadri(poly.x, poly.z, x/blocksize, z/blocksize)
+				if xf < 0 or xf > 1 or zf < 0 or zf > 1 then
+					print(xf, zf, x, z)
+				end
 				local i00, i01, i11, i10 = unpack(poly.i)
 
-				local is_river = false
+				local terrain_height = math.floor(interp(
-				local depth_factor = 0
+					dem[i00],
-				local r_west, r_north, r_east, r_south = unpack(poly.rivers)
+					dem[i01],
-				if xf >= r_east then
+					dem[i10],
-					is_river = true
+					dem[i11],
-					depth_factor = xf-r_east
-					xf = 1
-				elseif xf <= r_west then
-					is_river = true
-					depth_factor = r_west-xf
-					xf = 0
-				end
-				if zf >= r_south then
-					is_river = true
-					depth_factor = zf-r_south
-					zf = 1
-				elseif zf <= r_north then
-					is_river = true
-					depth_factor = r_north-zf
-					zf = 0
-				end
-
-				if not is_river then
-					local c_NW, c_NE, c_SE, c_SW = unpack(poly.river_corners)
-					if xf+zf <= c_NW then
-						is_river = true
-						depth_factor = c_NW-xf-zf
-						xf, zf = 0, 0
-					elseif 1-xf+zf <= c_NE then
-						is_river = true
-						depth_factor = c_NE-1+xf-zf
-						xf, zf = 1, 0
-					elseif 2-xf-zf <= c_SE then
-						is_river = true
-						depth_factor = c_SE-2+xf+zf
-						xf, zf = 1, 1
-					elseif xf+1-zf <= c_SW then
-						is_river = true
-						depth_factor = c_SW-xf-1+zf
-						xf, zf = 0, 1
-					end
-				end
-
-				if not is_river then
-					xf = (xf-r_west) / (r_east-r_west)
-					zf = (zf-r_north) / (r_south-r_north)
-				end
-
-				local vdem = poly.dem
-				local terrain_height = math.floor(0.5+interp(
-					vdem[1],
-					vdem[2],
-					vdem[3],
-					vdem[4],
 					xf, zf
 				))
 
-				local lake_height = math.max(math.floor(poly.lake), terrain_height)
+				local lake_height = math.floor(math.min(
-				if is_river then
+					lakes[i00],
-					terrain_height = math.min(math.max(lake_height, sea_level) - math.floor(1+depth_factor*riverbed_slope), terrain_height)
+					lakes[i01],
-				end
+					lakes[i10],
+					lakes[i11]
+				))
+
 				local is_lake = lake_height > terrain_height
+
+				local is_river = false
+				if xf < 1/6 then
+					if links[i00] == 1 and rivers[i00] >= min_catchment then
+						is_river = true
+					elseif links[i10] == 3 and rivers[i10] >= min_catchment then
+						is_river = true
+					end
+				end
+
+				if zf < 1/6 then
+					if links[i00] == 2 and rivers[i00] >= min_catchment then
+						is_river = true
+					elseif links[i01] == 4 and rivers[i01] >= min_catchment then
+						is_river = true
+					end
+				end
+				
 				local ivm = a:index(x, minp.y-1, z)
+
 				if terrain_height >= minp.y then
 					for y=minp.y, math.min(maxp.y, terrain_height) do
 						if y == terrain_height then
 							if is_lake or y <= sea_level then
 								data[ivm] = c_sand
+							elseif is_river then
+								data[ivm] = c_rwater
 							else
 								data[ivm] = c_lawn
 							end

load.lua

@@ -1,12 +1,11 @@
-local function load_map(filename, bytes, signed, size)
+local function load_map(filename, bytes, signed)
 	local file = io.open(filename, 'r')
 	local data = file:read('*all')
-	if #data < bytes*size then
-		data = minetest.decompress(data)
-	end
 
 	local map = {}
 
+	local size = math.floor(#data/bytes)
+
 	for i=1, size do
 		local i0, i1 = (i-1)*bytes+1, i*bytes
 		local elements = {data:byte(i0, i1)}

save.py

@@ -1,13 +1,8 @@
 import numpy as np
-import zlib
 
 def save(data, fname, dtype=None):
     if dtype is not None:
         data = data.astype(dtype)
 
-    bin_data = data.tobytes()
-    bin_data_comp = zlib.compress(bin_data, 9)
-    if len(bin_data_comp) < len(bin_data):
-        bin_data = bin_data_comp
     with open(fname, 'wb') as f:
-        f.write(bin_data)
+        f.write(data.tobytes())

settings.lua

@@ -1,41 +0,0 @@
-local storage = minetest.get_mod_storage()
-local settings = minetest.settings
-
-local function get_settings(key, dtype, default)
-	if storage:contains(key) then
-		if dtype == "string" then
-			return storage:get_string(key)
-		elseif dtype == "int" then
-			return storage:get_int(key)
-		elseif dtype == "float" then
-			return storage:get_float(key)
-		end
-	end
-
-	local conf_val = settings:get('mapgen_rivers_' .. key)
-	if conf_val then
-		if dtype == "int" then
-			conf_val = tonumber(conf_val)
-			storage:set_int(key, conf_val)
-		elseif dtype == "float" then
-			conf_val = tonumber(conf_val)
-			storage:set_float(key, conf_val)
-		elseif dtype == "string" then
-			storage:set_string(key, conf_val)
-		end
-
-		return conf_val
-	else
-		if dtype == "int" then
-			storage:set_int(key, default)
-		elseif dtype == "float" then
-			storage:set_float(key, default)
-		elseif dtype == "string" then
-			storage:set_string(key, default)
-		end
-
-		return default
-	end
-end
-
-return get_settings

terrain_rivers.py

@@ -23,7 +23,7 @@ n = np.zeros((mapsize, mapsize))
 #micronoise_depth = 0.05
 
 params = {
-    "octaves" : int(np.log2(mapsize)),
+    "octaves" : 8,
     "persistence" : 0.5,
     "lacunarity" : 2.,
 }
@@ -76,13 +76,11 @@ offset_y = np.clip(np.floor(oy * 256), -128, 127)
 
 save(model.dem, 'dem', dtype='>i2')
 save(model.lakes, 'lakes', dtype='>i2')
-save(np.abs(bx), 'bounds_x', dtype='>i4')
+save(model.dirs, 'links', dtype='u1')
-save(np.abs(by), 'bounds_y', dtype='>i4')
+save(model.rivers, 'rivers', dtype='>u4')
 save(offset_x, 'offset_x', dtype='i1')
 save(offset_y, 'offset_y', dtype='i1')
 
-save(model.rivers, 'rivers', dtype='>u4')
-
 with open('size', 'w') as sfile:
     sfile.write('{:d}\n{:d}'.format(mapsize, mapsize))
 

view_map.py

@@ -1,39 +0,0 @@
-#!/usr/bin/env python3
-
-import numpy as np
-import zlib
-import matplotlib.pyplot as plt
-
-def load_map(name, dtype, shape):
-    dtype = np.dtype(dtype)
-    with open(name, 'rb') as f:
-        data = f.read()
-    if len(data) < shape[0]*shape[1]*dtype.itemsize:
-        data = zlib.decompress(data)
-    return np.frombuffer(data, dtype=dtype).reshape(shape)
-
-shape = np.loadtxt('size', dtype='u4')
-n = shape[0] * shape[1]
-dem = load_map('dem', '>i2', shape)
-lakes = load_map('lakes', '>i2', shape)
-rivers = load_map('rivers', '>u4', shape)
-
-plt.subplot(1,3,1)
-plt.pcolormesh(dem, cmap='viridis')
-plt.gca().set_aspect('equal', 'box')
-#plt.colorbar(orientation='horizontal')
-plt.title('Raw elevation')
-
-plt.subplot(1,3,2)
-plt.pcolormesh(lakes, cmap='viridis')
-plt.gca().set_aspect('equal', 'box')
-#plt.colorbar(orientation='horizontal')
-plt.title('Lake surface elevation')
-
-plt.subplot(1,3,3)
-plt.pcolormesh(np.log(rivers), vmin=0, vmax=np.log(n/25), cmap='Blues')
-plt.gca().set_aspect('equal', 'box')
-#plt.colorbar(orientation='horizontal')
-plt.title('Rivers discharge')
-
-plt.show()