forked from VoxeLibre/VoxeLibre
105 lines
2.7 KiB
Lua
105 lines
2.7 KiB
Lua
local registered_generators = {}
|
|
|
|
local lvm, nodes, param2 = 0, 0, 0
|
|
local lvm_buffer = {}
|
|
|
|
minetest.register_on_generated(function(minp, maxp, blockseed)
|
|
minetest.log("action", "[mcl_mapgen_core] Generating chunk " .. minetest.pos_to_string(minp) .. " ... " .. minetest.pos_to_string(maxp))
|
|
local p1, p2 = {x=minp.x, y=minp.y, z=minp.z}, {x=maxp.x, y=maxp.y, z=maxp.z}
|
|
if lvm > 0 then
|
|
local lvm_used, shadow, deco_used = false, false
|
|
local lb2 = {} -- param2
|
|
local vm, emin, emax = minetest.get_mapgen_object("voxelmanip")
|
|
local e1, e2 = {x=emin.x, y=emin.y, z=emin.z}, {x=emax.x, y=emax.y, z=emax.z}
|
|
local data2
|
|
local data = vm:get_data(lvm_buffer)
|
|
if param2 > 0 then
|
|
data2 = vm:get_param2_data(lb2)
|
|
end
|
|
local area = VoxelArea:new({MinEdge=e1, MaxEdge=e2})
|
|
|
|
for _, rec in ipairs(registered_generators) do
|
|
if rec.vf then
|
|
local lvm_used0, shadow0, deco = rec.vf(vm, data, data2, e1, e2, area, p1, p2, blockseed)
|
|
if lvm_used0 then
|
|
lvm_used = true
|
|
end
|
|
if shadow0 then
|
|
shadow = true
|
|
end
|
|
if deco then
|
|
deco_used = true
|
|
end
|
|
end
|
|
end
|
|
|
|
if lvm_used then
|
|
-- Write stuff
|
|
vm:set_data(data)
|
|
if param2 > 0 then
|
|
vm:set_param2_data(data2)
|
|
end
|
|
if deco_used then
|
|
minetest.generate_decorations(vm)
|
|
end
|
|
vm:calc_lighting(p1, p2, shadow)
|
|
vm:write_to_map()
|
|
vm:update_liquids()
|
|
end
|
|
end
|
|
|
|
if nodes > 0 then
|
|
for _, rec in ipairs(registered_generators) do
|
|
if rec.nf then
|
|
rec.nf(p1, p2, blockseed)
|
|
end
|
|
end
|
|
end
|
|
|
|
mcl_vars.add_chunk(minp)
|
|
end)
|
|
|
|
function minetest.register_on_generated(node_function)
|
|
mcl_mapgen_core.register_generator("mod_"..minetest.get_current_modname().."_"..tostring(#registered_generators+1), nil, node_function)
|
|
end
|
|
|
|
function mcl_mapgen_core.register_generator(id, lvm_function, node_function, priority, needs_param2)
|
|
if not id then return end
|
|
|
|
local priority = priority or 5000
|
|
|
|
if lvm_function then lvm = lvm + 1 end
|
|
if node_function then nodes = nodes + 1 end
|
|
if needs_param2 then param2 = param2 + 1 end
|
|
|
|
local new_record = {
|
|
id = id,
|
|
i = priority,
|
|
vf = lvm_function,
|
|
nf = node_function,
|
|
needs_param2 = needs_param2,
|
|
}
|
|
|
|
table.insert(registered_generators, new_record)
|
|
table.sort(registered_generators, function(a, b)
|
|
return (a.i < b.i) or ((a.i == b.i) and a.vf and (b.vf == nil))
|
|
end)
|
|
end
|
|
|
|
function mcl_mapgen_core.unregister_generator(id)
|
|
local index
|
|
for i, gen in ipairs(registered_generators) do
|
|
if gen.id == id then
|
|
index = i
|
|
break
|
|
end
|
|
end
|
|
if not index then return end
|
|
local rec = registered_generators[index]
|
|
table.remove(registered_generators, index)
|
|
if rec.vf then lvm = lvm - 1 end
|
|
if rec.nf then nodes = nodes - 1 end
|
|
if rec.needs_param2 then param2 = param2 - 1 end
|
|
--if rec.needs_level0 then level0 = level0 - 1 end
|
|
end
|