vector_extras/init.lua

local path = minetest.get_modpath"vector_extras"

local funcs = {}

function funcs.pos_to_string(pos)
	return "("..pos.x.."|"..pos.y.."|"..pos.z..")"
end

local r_corr = 0.25 --remove a bit more nodes (if shooting diagonal) to let it
-- look like a hole (sth like antialiasing)

-- this doesn't need to be calculated every time
local f_1 = 0.5-r_corr
local f_2 = 0.5+r_corr

--returns information about the direction
local function get_used_dir(dir)
	local abs_dir = {x=math.abs(dir.x), y=math.abs(dir.y), z=math.abs(dir.z)}
	local dir_max = math.max(abs_dir.x, abs_dir.y, abs_dir.z)
	if dir_max == abs_dir.x then
		local tab = {"x", {x=1, y=dir.y/dir.x, z=dir.z/dir.x}}
		if dir.x >= 0 then
			tab[3] = "+"
		end
		return tab
	end
	if dir_max == abs_dir.y then
		local tab = {"y", {x=dir.x/dir.y, y=1, z=dir.z/dir.y}}
		if dir.y >= 0 then
			tab[3] = "+"
		end
		return tab
	end
	local tab = {"z", {x=dir.x/dir.z, y=dir.y/dir.z, z=1}}
	if dir.z >= 0 then
		tab[3] = "+"
	end
	return tab
end

local function node_tab(z, d)
	local n1 = math.floor(z*d+f_1)
	local n2 = math.floor(z*d+f_2)
	if n1 == n2 then
		return {n1}
	end
	return {n1, n2}
end

local function return_line(pos, dir, range) --range ~= length
	local tab = {}
	local num = 1
	local t_dir = get_used_dir(dir)
	local dir_typ = t_dir[1]
	if t_dir[3] == "+" then
		f_tab = {0, range, 1}
	else
		f_tab = {0, -range, -1}
	end
	local d_ch = t_dir[2]
	if dir_typ == "x" then
		for d = f_tab[1],f_tab[2],f_tab[3] do
			local x = d
			local ytab = node_tab(d_ch.y, d)
			local ztab = node_tab(d_ch.z, d)
			for _,y in ipairs(ytab) do
				for _,z in ipairs(ztab) do
					tab[num] = {x=pos.x+x, y=pos.y+y, z=pos.z+z}
					num = num+1
				end
			end
		end
	elseif dir_typ == "y" then
		for d = f_tab[1],f_tab[2],f_tab[3] do
			local xtab = node_tab(d_ch.x, d)
			local y = d
			local ztab = node_tab(d_ch.z, d)
			for _,x in ipairs(xtab) do
				for _,z in ipairs(ztab) do
					tab[num] = {x=pos.x+x, y=pos.y+y, z=pos.z+z}
					num = num+1
				end
			end
		end
	else
		for d = f_tab[1],f_tab[2],f_tab[3] do
			local xtab = node_tab(d_ch.x, d)
			local ytab = node_tab(d_ch.y, d)
			local z = d
			for _,x in ipairs(xtab) do
				for _,y in ipairs(ytab) do
					tab[num] = {x=pos.x+x, y=pos.y+y, z=pos.z+z}
					num = num+1
				end
			end
		end
	end
	return tab
end

function funcs.rayIter(pos, dir)
	-- make a table of possible movements
	local step = {}
	for i in pairs(pos) do
		local v = math.sign(dir[i])
		if v ~= 0 then
			step[i] = v
		end
	end

	local p
	return function()
		if not p then
			-- avoid skipping the first position
			p = vector.round(pos)
			return vector.new(p)
		end

		-- find the position which has the smallest distance to the line
		local choose = {}
		local choosefit = vector.new()
		for i in pairs(step) do
			choose[i] = vector.new(p)
			choose[i][i] = choose[i][i] + step[i]
			choosefit[i] = vector.scalar(vector.normalize(vector.subtract(choose[i], pos)), dir)
		end
		p = choose[vector.get_max_coord(choosefit)]

		return vector.new(p)
	end
end

function funcs.fine_line(pos, dir, range)
	if not range then --dir = pos2
		dir, range = vector.direction(pos, dir), vector.distance(pos, dir)
	end
	local result,n = {},1
	for p in vector.rayIter(pos, dir) do
		if vector.distance(p, pos) > range then
			break
		end
		result[n] = p
		n = n+1
	end
	return result
end

function funcs.line(pos, dir, range, alt)
	--assert_vector(pos)
	if alt then
		if not range then --dir = pos2
			dir, range = vector.direction(pos, dir), vector.distance(pos, dir)
		end
		return return_line(pos, dir, range)
	end
	if range then
		dir = vector.round(vector.multiply(dir, range))
	else --dir = pos2
		dir = vector.subtract(dir, pos)
	end
	local line,n = {},1
	for _,i in ipairs(vector.threeline(dir.x, dir.y, dir.z)) do
		line[n] = {x=pos.x+i[1], y=pos.y+i[2], z=pos.z+i[3]}
		n = n+1
	end
	return line
end

local twolines = {}
function funcs.twoline(x, y)
	local pstr = x.." "..y
	local line = twolines[pstr]
	if line then
		return line
	end
	line = {}
	local n = 1
	local dirx = 1
	if x < 0 then
		dirx = -dirx
	end
	local ymin, ymax = 0, y
	if y < 0 then
		ymin, ymax = ymax, ymin
	end
	local m = y/x --y/0 works too
	local dir = 1
	if m < 0 then
		dir = -dir
	end
	for i = 0,x,dirx do
		local p1 = math.max(math.min(math.floor((i-0.5)*m+0.5), ymax), ymin)
		local p2 = math.max(math.min(math.floor((i+0.5)*m+0.5), ymax), ymin)
		for j = p1,p2,dir do
			line[n] = {i, j}
			n = n+1
		end
	end
	twolines[pstr] = line
	return line
end

local threelines = {}
function funcs.threeline(x, y, z)
	local pstr = x.." "..y.." "..z
	local line = threelines[pstr]
	if line then
		return line
	end
	if x ~= math.floor(x) then
		minetest.log("error", "[vector_extras] INFO: The position used for " ..
			"vector.threeline isn't round.")
	end
	local two_line = vector.twoline(x, y)
	line = {}
	local n = 1
	local zmin, zmax = 0, z
	if z < 0 then
		zmin, zmax = zmax, zmin
	end
	local m = z/math.hypot(x, y)
	local dir = 1
	if m < 0 then
		dir = -dir
	end
	for _,i in ipairs(two_line) do
		local px, py = unpack(i)
		local ph = math.hypot(px, py)
		local z1 = math.max(math.min(math.floor((ph-0.5)*m+0.5), zmax), zmin)
		local z2 = math.max(math.min(math.floor((ph+0.5)*m+0.5), zmax), zmin)
		for pz = z1,z2,dir do
			line[n] = {px, py, pz}
			n = n+1
		end
	end
	threelines[pstr] = line
	return line
end

function funcs.sort_positions(ps, preferred_coords)
	preferred_coords = preferred_coords or {"z", "y", "x"}
	local a,b,c = unpack(preferred_coords)
	local function ps_sorting(p1, p2)
		if p1[a] == p2[a] then
			if p1[b] == p2[a] then
				if p1[c] < p2[c] then
					return true
				end
			elseif p1[b] < p2[b] then
				return true
			end
		elseif p1[a] < p2[a] then
			return true
		end
	end
	table.sort(ps, ps_sorting)
end

-- Tschebyschew norm
function funcs.maxnorm(v)
	return math.max(math.max(math.abs(v.x), math.abs(v.y)), math.abs(v.z))
end

function funcs.sumnorm(v)
	return math.abs(v.x) + math.abs(v.y) + math.abs(v.z)
end

function funcs.pnorm(v, p)
	return (math.abs(v.x)^p + math.abs(v.y)^p + math.abs(v.z)^p)^(1 / p)
end

--not optimized
--local areas = {}
function funcs.plane(ps)
	-- sort positions and imagine the first one (A) as vector.zero
	ps = vector.sort_positions(ps)
	local pos = ps[1]
	local B = vector.subtract(ps[2], pos)
	local C = vector.subtract(ps[3], pos)

	-- get the positions for the fors
	local cube_p1 = {x=0, y=0, z=0}
	local cube_p2 = {x=0, y=0, z=0}
	for i in pairs(cube_p1) do
		cube_p1[i] = math.min(B[i], C[i], 0)
		cube_p2[i] = math.max(B[i], C[i], 0)
	end
	cube_p1 = vector.apply(cube_p1, math.floor)
	cube_p2 = vector.apply(cube_p2, math.ceil)

	local vn = vector.normalize(vector.cross(B, C))

	local nAB = vector.normalize(B)
	local nAC = vector.normalize(C)
	local angle_BAC = math.acos(vector.scalar(nAB, nAC))

	local nBA = vector.multiply(nAB, -1)
	local nBC = vector.normalize(vector.subtract(C, B))
	local angle_ABC = math.acos(vector.scalar(nBA, nBC))

	for z = cube_p1.z, cube_p2.z do
		for y = cube_p1.y, cube_p2.y do
			for x = cube_p1.x, cube_p2.x do
				local p = {x=x, y=y, z=z}
				local n = -vector.scalar(p, vn)/vector.scalar(vn, vn)
				if math.abs(n) <= 0.5 then
					local ep = vector.add(p, vector.multiply(vn, n))
					local nep = vector.normalize(ep)
					local angle_BAep = math.acos(vector.scalar(nAB, nep))
					local angle_CAep = math.acos(vector.scalar(nAC, nep))
					local angldif = angle_BAC - (angle_BAep+angle_CAep)
					if math.abs(angldif) < 0.001 then
						ep = vector.subtract(ep, B)
						nep = vector.normalize(ep)
						local angle_ABep = math.acos(vector.scalar(nBA, nep))
						local angle_CBep = math.acos(vector.scalar(nBC, nep))
						local angldif = angle_ABC - (angle_ABep+angle_CBep)
						if math.abs(angldif) < 0.001 then
							table.insert(ps, vector.add(pos, p))
						end
					end
				end
			end
		end
	end
	return ps
end

function funcs.straightdelay(s, v, a)
	if not a then
		return s/v
	end
	return (math.sqrt(v*v+2*a*s)-v)/a
end

vector.zero = vector.new()

function funcs.sun_dir(time)
	if not time then
		time = minetest.get_timeofday()
	end
	local t = (time-0.5)*5/6+0.5 --the sun rises at 5 o'clock, not at 6
	if t < 0.25
	or t > 0.75 then
		return
	end
	local tmp = math.cos(math.pi*(2*t-0.5))
	return {x=tmp, y=math.sqrt(1-tmp*tmp), z=0}
end

function funcs.inside(pos, minp, maxp)
	for _,i in pairs({"x", "y", "z"}) do
		if pos[i] < minp[i]
		or pos[i] > maxp[i] then
			return false
		end
	end
	return true
end

function funcs.minmax(p1, p2)
	local p1 = vector.new(p1)
	local p2 = vector.new(p2)
	for _,i in ipairs({"x", "y", "z"}) do
		if p1[i] > p2[i] then
			p1[i], p2[i] = p2[i], p1[i]
		end
	end
	return p1, p2
end

function funcs.move(p1, p2, s)
	return vector.round(
		vector.add(
			vector.multiply(
				vector.direction(
					p1,
					p2
				),
				s
			),
			p1
		)
	)
end

function funcs.from_number(i)
	return {x=i, y=i, z=i}
end

local adammil_fill = dofile(path .. "/adammil_flood_fill.lua")
function funcs.search_2d(go_test, x0, y0, allow_revisit, give_map)
	marked_places = adammil_fill(go_test, x0, y0, allow_revisit)
	if give_map then
		return marked_places
	end
	local l = {}
	for vi in pairs(marked_places) do
		local x = (vi % 65536) - 32768
		local y = (math.floor(x / 65536) % 65536) - 32768
		l[#l+1] = {x, y}
	end
	return l
end

local fallings_search = dofile(path .. "/fill_3d.lua")
local moves_touch = {
	{x = -1, y = 0, z = 0},
	{x = 0, y = 0, z = 0},
	{x = 1, y = 0, z = 0},
	{x = 0, y = -1, z = 0},
	{x = 0, y = 1, z = 0},
	{x = 0, y = 0, z = -1},
	{x = 0, y = 0, z = 1},
}
local moves_near = {}
for z = -1,1 do
	for y = -1,1 do
		for x = -1,1 do
			moves_near[#moves_near+1] = {x = x, y = y, z = z}
		end
	end
end

function funcs.search_3d(can_go, startpos, apply_move, moves)
	local visited = {}
	local found = {}
	local function on_visit(pos)
		local vi = minetest.hash_node_position(pos)
		if visited[vi] then
			return false
		end
		visited[vi] = true
		local valid_pos = can_go(pos)
		if valid_pos then
			found[#found+1] = pos
		end
		return valid_pos
	end
	if apply_move == "touch" then
		apply_move = vector.add
		moves = moves_touch
	elseif apply_move == "near" then
		apply_move = vector.add
		moves = moves_near
	end
	fallings_search(on_visit, startpos, apply_move, moves)
end


local explosion_tables = {}
function funcs.explosion_table(r)
	local table = explosion_tables[r]
	if table then
		return table
	end

	--~ local t1 = os.clock()
	local tab, n = {}, 1

	local tmp = r*r + r
	for x=-r,r do
		for y=-r,r do
			for z=-r,r do
				local rc = x*x+y*y+z*z
				if rc <= tmp then
					local np={x=x, y=y, z=z}
					if math.floor(math.sqrt(rc) +0.5) > r-1 then
						tab[n] = {np, true}
					else
						tab[n] = {np}
					end
					n = n+1
				end
			end
		end
	end
	explosion_tables[r] = tab
	--~ minetest.log("info", string.format("[vector_extras] table created after ca. %.2fs", os.clock() - t1))
	return tab
end

local default_nparams = {
   offset = 0,
   scale = 1,
   seed = 1337,
   octaves = 6,
   persist = 0.6
}
function funcs.explosion_perlin(rmin, rmax, nparams)
	local t1 = os.clock()

	local r = math.ceil(rmax)
	nparams = nparams or {}
	for i,v in pairs(default_nparams) do
		nparams[i] = nparams[i] or v
	end
	nparams.spread = nparams.spread or vector.from_number(r*5)

	local pos = {x=math.random(-30000, 30000), y=math.random(-30000, 30000), z=math.random(-30000, 30000)}
	local map = minetest.get_perlin_map(nparams, vector.from_number(r+r+1)):get3dMap_flat(pos)

	local id = 1

	local bare_maxdist = rmax*rmax
	local bare_mindist = rmin*rmin

	local mindist = math.sqrt(bare_mindist)
	local dist_diff = math.sqrt(bare_maxdist)-mindist
	mindist = mindist/dist_diff

	local pval_min, pval_max

	local tab, n = {}, 1
	for z=-r,r do
		local bare_dist = z*z
		for y=-r,r do
			local bare_dist = bare_dist+y*y
			for x=-r,r do
				local bare_dist = bare_dist+x*x
				local add = bare_dist < bare_mindist
				local pval, distdiv
				if not add
				and bare_dist <= bare_maxdist then
					distdiv = math.sqrt(bare_dist)/dist_diff-mindist
					pval = math.abs(map[id]) -- strange perlin values…
					if not pval_min then
						pval_min = pval
						pval_max = pval
					else
						pval_min = math.min(pval, pval_min)
						pval_max = math.max(pval, pval_max)
					end
					add = true--distdiv < 1-math.abs(map[id])
				end

				if add then
					tab[n] = {{x=x, y=y, z=z}, pval, distdiv}
					n = n+1
				end
				id = id+1
			end
		end
	end

	map = nil
	collectgarbage()

	-- change strange values
	local pval_diff = pval_max - pval_min
	pval_min = pval_min/pval_diff

	for n,i in pairs(tab) do
		if i[2] then
			local new_pval = math.abs(i[2]/pval_diff - pval_min)
			if i[3]+0.33 < new_pval then
				tab[n] = {i[1]}
			elseif i[3] < new_pval then
				tab[n] = {i[1], true}
			else
				tab[n] = nil
			end
		end
	end

	minetest.log("info", string.format("[vector_extras] table created after ca. %.2fs", os.clock() - t1))
	return tab
end

local circle_tables = {}
function funcs.circle(r)
	local table = circle_tables[r]
	if table then
		return table
	end

	local t1 = os.clock()
	local tab, n = {}, 1

	for i = -r, r do
		for j = -r, r do
			if math.floor(math.sqrt(i*i+j*j)+0.5) == r then
				tab[n] = {x=i, y=0, z=j}
				n = n+1
			end
		end
	end
	circle_tables[r] = tab
	minetest.log("info", string.format("[vector_extras] table created after ca. %.2fs", os.clock() - t1))
	return tab
end

local ring_tables = {}
function funcs.ring(r)
	local table = ring_tables[r]
	if table then
		return table
	end

	local t1 = os.clock()
	local tab, n = {}, 1

	local tmp = r*r
	local p = {x=math.floor(r+0.5), z=0}
	while p.x > 0 do
		tab[n] = p
		n = n+1
		local p1, p2 = {x=p.x-1, z=p.z}, {x=p.x, z=p.z+1}
		local dif1 = math.abs(tmp-p1.x*p1.x-p1.z*p1.z)
		local dif2 = math.abs(tmp-p2.x*p2.x-p2.z*p2.z)
		if dif1 <= dif2 then
			p = p1
		else
			p = p2
		end
	end

	local tab2 = {}
	n = 1
	for _,i in ipairs(tab) do
		for _,j in ipairs({
			{i.x, i.z},
			{-i.z, i.x},
			{-i.x, -i.z},
			{i.z, -i.x},
		}) do
			tab2[n] = {x=j[1], y=0, z=j[2]}
			n = n+1
		end
	end
	ring_tables[r] = tab2
	minetest.log("info", string.format("[vector_extras] table created after ca. %.2fs", os.clock() - t1))
	return tab2
end

	--~ posy(t) = att + bt + c
	--~ vely(t) = 2at + b
	--~ accy(t) = 2a

	--~ a = -0.5gravity
	--~ vely(0) = b = vel.y
	--~ posy(0) = c = pos.y

	--~ posy(t) = -0.5 * gravity * t * t + vel.y * t + pos.y
	--~ vely(t) = -gravity*t + vel.y

	--~ Scheitel:
	--~ vely(t) = 0 = -gravity*t + vel.y
	--~ t = vel.y / gravity

	--~ 45°
	--~ vely(t)^2 = velx(t)^2 + velz(t)^2
	--~ (-gravity*t + vel.y)^2 = vel.x * vel.x + vel.z * vel.z
	--~ gravity^2 * t^2 + vel.y^2 - -2*gravity*t*vel.y = vel.x * vel.x + vel.z * vel.z
	--~ gravity^2 * t^2 - 2*gravity*vel.y * t + (vel.y^2 - vel.x^2 - vel.z^2) = 0
	--~ t = (2*gravity*vel.y .. rt((2*gravity*vel.y)^2 - 4*gravity^2*(vel.y^2 - vel.x^2 - vel.z^2))) / (2*gravity^2)
	--~ t = (2*gravity*vel.y .. rt(4*gravity^2*vel.y^2 - 4*gravity^2*(vel.y^2) + 4*gravity^2*(vel.x^2 + vel.z^2))) / (2*gravity^2)
	--~ t = (2*gravity*vel.y .. 2*gravity*rt(vel.x^2 + vel.z^2)) / (2*gravity^2)
	--~ t = (vel.y .. rt(vel.x^2 + vel.z^2)) / gravity
	--~ t1 = (vel.y - math.sqrt(vel.x * vel.x + vel.z * vel.z)) / gravity
	--~ t2 = (vel.y + math.sqrt(vel.x * vel.x + vel.z * vel.z)) / gravity

	--~ yswitch = posy(t1) (= posy(t2)) //links und rechts gleich
	--~ yswitch = -0.5 * gravity * ((vel.y + math.sqrt(vel.x * vel.x + vel.z * vel.z)) / gravity)^2 + vel.y * ((vel.y + math.sqrt(vel.x * vel.x + vel.z * vel.z)) / gravity) + pos.y
	--~ yswitch = -0.5 * gravity * (vel.y + math.sqrt(vel.x * vel.x + vel.z * vel.z))^2 / gravity^2 + vel.y * ((vel.y + math.sqrt(vel.x * vel.x + vel.z * vel.z)) / gravity) + pos.y
	--~ yswitch = -0.5 * (vel.y^2 + 2*vel.y*math.sqrt(vel.x * vel.x + vel.z * vel.z) + vel.x^2 + vel.z^2) / gravity + ((vel.y^2 + vel.y*math.sqrt(vel.x * vel.x + vel.z * vel.z)) / gravity) + pos.y
	--~ yswitch = (-0.5 * (vel.y^2 + 2*vel.y*math.sqrt(vel.x * vel.x + vel.z * vel.z) + vel.x^2 + vel.z^2) + ((vel.y^2 + vel.y*math.sqrt(vel.x * vel.x + vel.z * vel.z)))) / gravity + pos.y
	--~ yswitch = (-0.5 * vel.y^2 - vel.y*math.sqrt(vel.x * vel.x + vel.z * vel.z) - 0.5 * vel.x^2 - 0.5 * vel.z^2 + vel.y^2 + vel.y*math.sqrt(vel.x * vel.x + vel.z * vel.z)) / gravity + pos.y
	--~ yswitch = (-0.5 * vel.y^2 - 0.5 * vel.x^2 - 0.5 * vel.z^2 + vel.y^2) / gravity + pos.y
	--~ yswitch = (0.5 * vel.y^2 - 0.5 * vel.x^2 - 0.5 * vel.z^2) / gravity + pos.y
	--~ yswitch = -0.5 * (vel.x * vel.x + vel.z * vel.z - vel.y * vel.y) / gravity + pos.y


	--~ 45° Zeitpunkte kleineres beim Aufstieg, größeres beim Fall
	--~ (-gravity*t + vel.y)^2 = vel.x * vel.x + vel.z * vel.z
	--~ -gravity*t + vel.y = ..math.sqrt(vel.x * vel.x + vel.z * vel.z)
	--~ t = (..math.sqrt(vel.x * vel.x + vel.z * vel.z) + vel.y) / gravity
	--~ t_raise = (-math.sqrt(vel.x * vel.x + vel.z * vel.z) + vel.y) / gravity
	--~ t_fall = (math.sqrt(vel.x * vel.x + vel.z * vel.z) + vel.y) / gravity

	--~ posy nach t umstellen
	--~ y = -0.5 * gravity * t * t + vel.y * t + pos.y
	--~ 0 = -0.5 * gravity * t * t + vel.y * t + pos.y - y
	--~ t = (-vel.y .. math.sqrt(vel.y^2 + 2 * gravity * (pos.y - y))) / (-gravity)
	--~ t = (vel.y .. math.sqrt(vel.y^2 + 2 * gravity * (pos.y - y))) / gravity
	--~ t_up = (vel.y - math.sqrt(vel.y^2 + 2 * gravity * (pos.y - y))) / gravity
	--~ t_down = (vel.y + math.sqrt(vel.y^2 + 2 * gravity * (pos.y - y))) / gravity

	--~ posx(t) = vel.x * t + pos.x
	--~ posz(t) = vel.z * t + pos.z

	--~ posx nach t umstellen
	--~ posx - pos.x = vel.x * t
	--~ t = (posx - pos.x) / vel.x


local function get_parabola_points(pos, vel, gravity, waypoints, max_pointcount,
		time)
	local pointcount = 0

	-- the height of the 45° angle point
	local yswitch = -0.5 * (vel.x^2 + vel.z^2 - vel.y^2)
		/ gravity + pos.y

	-- the times of the 45° angle point
	local i = math.sqrt(vel.x^2 + vel.z^2)
	local t_raise_end = (-i + vel.y) / gravity
	local t_fall_start = (i + vel.y) / gravity
	if t_fall_start > 0 then
		-- the right 45° angle point wasn't passed yet
		if t_raise_end > 0 then
			-- put points from before the 45° angle
			for y = math.ceil(pos.y), math.floor(yswitch +.5) do
				local t = (vel.y -
					math.sqrt(vel.y^2 + 2 * gravity * (pos.y - y))) / gravity
				if t > time then
					return
				end
				local p = {
					x = math.floor(vel.x * t + pos.x +.5),
					y = y,
					z = math.floor(vel.z * t + pos.z +.5),
				}
				pointcount = pointcount+1
				waypoints[pointcount] = {p, t}
				if pointcount == max_pointcount then
					return
				end
			end
		end
		-- smaller and bigger horizonzal pivot
		local shp, bhp
		if math.abs(vel.x) > math.abs(vel.z) then
			shp = "z"
			bhp = "x"
		else
			shp = "x"
			bhp = "z"
		end
		-- put points between the 45° angles
		local cstart, cdir
		local cend = math.floor(vel[bhp] * t_fall_start + pos[bhp] +.5)
		if vel[bhp] > 0 then
			cstart = math.floor(math.max(pos[bhp],
				vel[bhp] * t_raise_end + pos[bhp]) +.5)
			cdir = 1
		else
			cstart = math.floor(math.min(pos[bhp],
				vel[bhp] * t_raise_end + pos[bhp]) +.5)
			cdir = -1
		end
		for i = cstart, cend, cdir do
			local t = (i - pos[bhp]) / vel[bhp]
			if t > time then
				return
			end
			local p = {
				[bhp] = i,
				y = math.floor(-0.5 * gravity * t * t + vel.y * t + pos.y +.5),
				[shp] = math.floor(vel[shp] * t + pos[shp] +.5),
			}
			pointcount = pointcount+1
			waypoints[pointcount] = {p, t}
			if pointcount == max_pointcount then
				return
			end
		end
	end
	-- put points from after the 45° angle
	local y = yswitch
	if vel.y < 0
	and pos.y < yswitch then
		y = pos.y
	end
	y = math.floor(y +.5)
	while pointcount < max_pointcount do
		local t = (vel.y +
			math.sqrt(vel.y^2 + 2 * gravity * (pos.y - y))) / gravity
		if t > time then
			return
		end
		local p = {
			x = math.floor(vel.x * t + pos.x +.5),
			y = y,
			z = math.floor(vel.z * t + pos.z +.5),
		}
		pointcount = pointcount+1
		waypoints[pointcount] = {p, t}
		y = y-1
	end
end
--[[
minetest.override_item("default:axe_wood", {
	on_use = function(_, player)
		local dir = player:get_look_dir()
		local pos = player:getpos()
		local grav = 0.03
		local ps = vector.throw_parabola(pos, dir, grav, 80)
		for i = 1,#ps do
			minetest.set_node(ps[i], {name="default:stone"})
		end
		--~ for t = 0,50,3 do
			--~ local p = {
				--~ x = dir.x * t + pos.x,
				--~ y = -0.5*grav*t*t + dir.y*t + pos.y,
				--~ z = dir.z * t + pos.z
			--~ }
			--~ minetest.set_node(p, {name="default:sandstone"})
		--~ end
	end,
})--]]

function funcs.throw_parabola(pos, vel, gravity, point_count, time)
	local waypoints = {}
	get_parabola_points(pos, vel, gravity, waypoints, point_count,
			time or math.huge)
	local ps = {}
	local ptscnt = #waypoints
	local i = 1
	while i < ptscnt do
		local p,t = unpack(waypoints[i])
		i = i+1
		local p2,t2 = unpack(waypoints[i])
		ps[#ps+1] = p
		local dist = vector.distance(p, p2)
		if dist < 1.1 then
			if dist < 0.9 then
				-- same position
				i = i+1
			end
			-- touching
		elseif dist < 1.7 then
			-- common edge
			-- get a list of possible positions between
			local diff = vector.subtract(p2, p)
			local possible_positions = {}
			for i,v in pairs(diff) do
				if v ~= 0 then
					local p = vector.new(p)
					p[i] = p[i] + v
					possible_positions[#possible_positions+1] = p
				end
			end
			-- test which one fits best
			t = 0.5 * (t + t2)
			local near_p = {
				x = vel.x * t + pos.x,
				y = -0.5 * gravity * t * t + vel.y * t + pos.y,
				z = vel.z * t + pos.z,
			}
			local d = math.huge
			for i = 1,2 do
				local pos = possible_positions[i]
				local dist = vector.distance(pos, near_p)
				if dist < d then
					p = pos
					d = dist
				end
			end
			-- add it
			ps[#ps+1] = p
		elseif dist < 1.8 then
			-- common vertex
			for k = 1,2 do
				-- get a list of possible positions between
				local diff = vector.subtract(p2, p)
				local possible_positions = {}
				for i,v in pairs(diff) do
					if v ~= 0 then
						local p = vector.new(p)
						p[i] = p[i] + v
						possible_positions[#possible_positions+1] = p
					end
				end
				-- test which one fits best
				t = k / 3 * (t + t2)
				local near_p = {
					x = vel.x * t + pos.x,
					y = -0.5 * gravity * t * t + vel.y * t + pos.y,
					z = vel.z * t + pos.z,
				}
				local d = math.huge
				assert(#possible_positions == 4-k, "how, number positions?")
				for i = 1,4-k do
					local pos = possible_positions[i]
					local dist = vector.distance(pos, near_p)
					if dist < d then
						p = pos
						d = dist
					end
				end
				-- add it
				ps[#ps+1] = p
			end
		else
			minetest.log("warning", "[vector_extras] A gap: " .. dist)
			--~ error("A gap, it's a gap!: " .. dist)
		end
	end
	if i == ptscnt then
		ps[#ps+1] = waypoints[i]
	end
	return ps
end

function funcs.chunkcorner(pos)
	return {x=pos.x-pos.x%16, y=pos.y-pos.y%16, z=pos.z-pos.z%16}
end

function funcs.point_distance_minmax(p1, p2)
	local p1 = vector.new(p1)
	local p2 = vector.new(p2)
	local min, max, vmin, vmax, num
	for _,i in ipairs({"x", "y", "z"}) do
		num = math.abs(p1[i] - p2[i])
		if not vmin or num < vmin then
			vmin = num
			min = i
		end
		if not vmax or num > vmax then
			vmax = num
			max = i
		end
	end
	return min, max
end

function funcs.collision(p1, p2)
	local clear, node_pos, collision_pos, max, dmax, dcmax, pt
	clear, node_pos = minetest.line_of_sight(p1, p2)
	if clear then
		return false
	end
	collision_pos = {}
	min, max = funcs.point_distance_minmax(node_pos, p2)
	if node_pos[max] > p2[max] then
		collision_pos[max] = node_pos[max] - 0.5
	else
		collision_pos[max] = node_pos[max] + 0.5
	end
	dmax = p2[max] - node_pos[max]
	dcmax = p2[max] - collision_pos[max]
	pt = dcmax/dmax

	for _,i in ipairs({"x", "y", "z"}) do
		collision_pos[i] = p2[i] - (p2[i] - node_pos[i]) * pt
	end
	return true, collision_pos, node_pos
end

function funcs.update_minp_maxp(minp, maxp, pos)
	for _,i in pairs({"z", "y", "x"}) do
		minp[i] = math.min(minp[i], pos[i])
		maxp[i] = math.max(maxp[i], pos[i])
	end
end

function funcs.quickadd(pos, z,y,x)
	if z then
		pos.z = pos.z+z
	end
	if y then
		pos.y = pos.y+y
	end
	if x then
		pos.x = pos.x+x
	end
end

function funcs.unpack(pos)
	return pos.z, pos.y, pos.x
end

function funcs.get_max_coord(vec)
	if vec.x < vec.y then
		if vec.y < vec.z then
			return "z"
		end
		return "y"
	end
	if vec.x < vec.z then
		return "z"
	end
	return "x"
end

function funcs.get_max_coords(pos)
	if pos.x < pos.y then
		if pos.y < pos.z then
			return "z", "y", "x"
		end
		if pos.x < pos.z then
			return "y", "z", "x"
		end
		return "y", "x", "z"
	end
	if pos.x < pos.z then
		return "z", "x", "y"
	end
	if pos.y < pos.z then
		return "x", "z", "y"
	end
	return "x", "y", "z"
end

function funcs.serialize(vec)
	return "{x=" .. vec.x .. ",y=" .. vec.y .. ",z=" .. vec.z .. "}"
end

function funcs.triangle(pos1, pos2, pos3)
	local normal = vector.cross(vector.subtract(pos2, pos1),
		vector.subtract(pos3, pos1))
	-- Find the biggest absolute component of the normal vector
	local dir = vector.get_max_coord({
		x = math.abs(normal.x),
		y = math.abs(normal.y),
		z = math.abs(normal.z),
	})
	-- Find the other directions for the for loops
	local all_other_dirs = {
		x = {"z", "y"},
		y = {"z", "x"},
		z = {"y", "x"},
	}
	local other_dirs = all_other_dirs[dir]
	local odir1, odir2 = other_dirs[1], other_dirs[2]

	local pos1_2d = {pos1[odir1], pos1[odir2]}
	local pos2_2d = {pos2[odir1], pos2[odir2]}
	local pos3_2d = {pos3[odir1], pos3[odir2]}
	-- The boundaries of the 2D AABB along other_dirs
	local p1 = {}
	local p2 = {}
	for i = 1,2 do
		p1[i] = math.floor(math.min(pos1_2d[i], pos2_2d[i], pos3_2d[i]))
		p2[i] = math.ceil(math.max(pos1_2d[i], pos2_2d[i], pos3_2d[i]))
	end

	-- https://www.scratchapixel.com/lessons/3d-basic-rendering/rasterization-practical-implementation/rasterization-stage
	local function edgefunc(p1, p2, pos)
		return (pos[1] - p1[1]) * (p2[2] - p1[2])
			- (pos[2] - p1[2]) * (p2[1] - p1[1])
	end
	-- eps is used to prevend holes in neighbouring triangles
	-- It should be smaller than the smallest possible barycentric value
	-- FIXME: I'm not sure if it really does what it should.
	local eps = 0.5 / math.max(p2[1] - p1[1], p2[2] - p1[2])
	local a_all_inv = 1.0 / edgefunc(pos1_2d, pos2_2d, pos3_2d)
	local step_k3 = - (pos2_2d[1] - pos1_2d[1]) * a_all_inv
	local step_k1 = - (pos3_2d[1] - pos2_2d[1]) * a_all_inv
	-- Calculate the triangle points
	local points = {}
	local barycentric_coords = {}
	local n = 0
	-- It is possible to further optimize this
	for v1 = p1[1], p2[1] do
		local p = {v1, p1[2]}
		local k3 = edgefunc(pos1_2d, pos2_2d, p) * a_all_inv
		local k1 = edgefunc(pos2_2d, pos3_2d, p) * a_all_inv
		for _ = p1[2], p2[2] do
			local k2 = 1 - k1 - k3
			if k1 >= -eps and k2 >= -eps and k3 >= -eps then
				-- On triangle
				local h = math.floor(k1 * pos1[dir] + k2 * pos2[dir] +
					k3 * pos3[dir] + 0.5)
				n = n+1
				points[n] = {[odir1] = v1, [odir2] = p[2], [dir] = h}
				barycentric_coords[n] = {k1, k2, k3}
			end
			p[2] = p[2]+1
			k3 = k3 + step_k3
			k1 = k1 + step_k1
		end
	end
	return points, n, barycentric_coords
end


vector_extras_functions = funcs

dofile(path .. "/legacy.lua")
--dofile(minetest.get_modpath("vector_extras").."/vector_meta.lua")

vector_extras_functions = nil


for name,func in pairs(funcs) do
	if vector[name] then
		minetest.log("error", "[vector_extras] vector."..name..
			" already exists.")
	else
		vector[name] = func
	end
end