595 lines
14 KiB
Lua
595 lines
14 KiB
Lua
--[[
|
|
|
|
k_smallblocks is a Minetest mod that adds smaller blocks to minetest aswell as
|
|
its own node placement prediction/system
|
|
|
|
Copyright (C) 2019 Kurtzmusch
|
|
|
|
This file is part of k_smallblocks
|
|
|
|
k_smallblocks is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU Lesser General Public License as published by the Free
|
|
Software Foundation; either version 2.1 of the License, or (at your option) any
|
|
later version.
|
|
|
|
k_smallblocks is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
|
|
PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License along
|
|
with k_smallblocks. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
--]]
|
|
|
|
-- bitmap is an array of 8 integers that can be either 0 or 1
|
|
-- it is used to indicate wich part of the node is filled with a smallblock
|
|
|
|
|
|
util = {}
|
|
util.table_invert = function(t)
|
|
local s={}
|
|
for k,v in pairs(t) do
|
|
s[v]=k
|
|
end
|
|
return s
|
|
end
|
|
util.table_shallow_copy = function(t)
|
|
local t2 = {}
|
|
for k,v in pairs(t) do
|
|
t2[k] = v
|
|
end
|
|
return t2
|
|
end
|
|
|
|
-- does the equivalent of a bitwise OR with 2 bitmaps
|
|
util.or_bitmap = function( array1, array2 )
|
|
local result = { [7] = nil }
|
|
local index = 0
|
|
while (index < 8 ) do
|
|
if( (array1[index] == 1) or (array2[index] == 1) ) then
|
|
result[index] = 1
|
|
else
|
|
result[index] = 0
|
|
end
|
|
|
|
index = index + 1
|
|
end
|
|
return result
|
|
end
|
|
|
|
util.xor_bitmap = function( bitmap1, bitmap2 )
|
|
local result = {}
|
|
local index = 0
|
|
while(index<8) do
|
|
if(
|
|
( (bitmap1[index] == 1) or (bitmap2[index] == 1 ) )
|
|
and
|
|
( (bitmap1[index] == 0) or (bitmap2[index] == 0 ) )
|
|
) then
|
|
result[index] = 1
|
|
else
|
|
result[index] = 0
|
|
end
|
|
index = index + 1
|
|
end
|
|
|
|
return result
|
|
|
|
end
|
|
|
|
-- convert world coordinates into node coordinates, ranging from 0 to 1
|
|
util.worldPoint_to_nodePoint = function( point )
|
|
point.x = point.x + 65536.5
|
|
point.y = point.y + 65536.5
|
|
point.z = point.z + 65536.5
|
|
|
|
return { x=point.x%1, y=point.y%1, z=point.z%1 }
|
|
end
|
|
|
|
-- converts a point in a node into a bitmap
|
|
-- input coords must be between 0 and 1
|
|
-- the bitmap is empty, except for the smallblock in the given coordinate
|
|
util.nodePoint_to_bitmap = function( point )
|
|
local size = 2 -- lenght of a node in smallblocks
|
|
|
|
-- floored components are indexes of a 3d array
|
|
local floored_point = {}
|
|
floored_point.x = math.floor( point.x*2 )
|
|
floored_point.y = math.floor( point.y*2 )
|
|
floored_point.z = math.floor( point.z*2 )
|
|
|
|
bitmap = {}
|
|
local index = 0
|
|
while (index < 8) do
|
|
bitmap[index] = 0
|
|
index = index + 1
|
|
end
|
|
|
|
-- this is like converting a 3d array to a 1d array
|
|
index =
|
|
(floored_point.x) +
|
|
(floored_point.y*size) +
|
|
(floored_point.z*(size*size))
|
|
|
|
bitmap[index] = 1
|
|
return bitmap
|
|
end
|
|
|
|
util.nodePoint_to_bitmap4x4 = function( point )
|
|
local result = {}
|
|
for x=0, 3, 1 do
|
|
result[x] = {}
|
|
for y=0, 3, 1 do
|
|
result[x][y] = {}
|
|
for z=0, 3, 1 do
|
|
result[x][y][z] = 0
|
|
end
|
|
end
|
|
end
|
|
local size = 4
|
|
minetest.log( "warning", point.x.."|"..point.y.."|"..point.z )
|
|
|
|
local floored_point = {}
|
|
floored_point.x = math.floor( point.x*size )
|
|
floored_point.y = math.floor( point.y*size )
|
|
floored_point.z = math.floor( point.z*size )
|
|
minetest.log( "warning", point.x.."|"..point.y.."|"..point.z )
|
|
minetest.log( "error", floored_point.x.."|"..floored_point.y.."|"..floored_point.z )
|
|
result[floored_point.x][floored_point.y][floored_point.z] = 1
|
|
return result
|
|
end
|
|
|
|
-- this assumes only one of the values is 1
|
|
util.bitmap4x4_to_facetype = function( bitmap4x4 )
|
|
--find indexes
|
|
local ix
|
|
local iy
|
|
local iz
|
|
for x=0, 3, 1 do
|
|
for y=0, 3, 1 do
|
|
for z=0, 3, 1 do
|
|
if( bitmap4x4[x][y][z] == 1 ) then
|
|
ix = x
|
|
iy = y
|
|
iz = z
|
|
end
|
|
end
|
|
end
|
|
end
|
|
-- count indexes at edge of array
|
|
local edge_indexes = 0
|
|
if( ( ix == 0) or (ix == 3) ) then edge_indexes = edge_indexes + 1 end
|
|
if( ( iy == 0) or (iy == 3) ) then edge_indexes = edge_indexes + 1 end
|
|
if( ( iz == 0) or (iz == 3) ) then edge_indexes = edge_indexes + 1 end
|
|
minetest.chat_send_all( ix.." "..iy.." "..iz )
|
|
|
|
if( edge_indexes == 3 ) then return "corner" end
|
|
if( edge_indexes == 2 ) then return "edge" end
|
|
if( edge_indexes == 1 ) then return "face" end
|
|
|
|
return "unsuported"
|
|
|
|
end
|
|
|
|
util.bitmap4x4_to_bitmap2x2 = function( bitmap4x4 )
|
|
local result = {}
|
|
local point_list = {}
|
|
local i = 0
|
|
for ix=0, 3, 1 do
|
|
for iy=0, 3, 1 do
|
|
for iz=0, 3, 1 do
|
|
if( bitmap4x4[ix][iy][iz] == 1 ) then
|
|
point_list[i] = { x=ix/4.0,y=iy/4.0,z=iz/4.0 }
|
|
i = i + 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
local new_point_list = {}
|
|
for k, v in pairs(point_list) do
|
|
minetest.log( "warning", v.x..":"..math.floor(v.x*2).." ".. v.y..":"..math.floor(v.y*2).." ".. v.z..":"..math.floor(v.z*2) )
|
|
new_point_list[k] = { x=math.floor(v.x*2), y=math.floor(v.y*2), z=math.floor(v.z*2) }
|
|
end
|
|
for ix=0, 1, 1 do
|
|
result[ix] = {}
|
|
for iy=0, 1, 1 do
|
|
result[ix][iy] = {}
|
|
for iz=0, 1, 1 do
|
|
result[ix][iy][iz] = 0
|
|
end
|
|
end
|
|
end
|
|
for k, v in pairs(new_point_list) do
|
|
minetest.log( "none", v.x..v.y..v.z )
|
|
result[v.x][v.y][v.z] = 1
|
|
end
|
|
|
|
return result
|
|
end
|
|
|
|
-- assumes you give it a bitmap of type edge-expanded
|
|
util.bitmap4x4_expand_faces = function( bitmap4x4 )
|
|
-- remove corners
|
|
for x=0, 3, 1 do
|
|
for y=0, 3, 1 do
|
|
for z=0, 3, 1 do
|
|
if( bitmap4x4[x][y][z] == 1 ) then
|
|
if( -- if its a corner
|
|
( (x==0) or (x==3) )
|
|
and ( (y==0) or (y==3) )
|
|
and ( (z==0) or (z==3) )
|
|
) then
|
|
bitmap4x4[x][y][z] = 0
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
--find faces
|
|
local ix
|
|
local iy
|
|
local iz
|
|
local dimension = {}
|
|
for x=0, 3, 1 do
|
|
for y=0, 3, 1 do
|
|
for z=0, 3, 1 do
|
|
if( bitmap4x4[x][y][z] == 1 ) then
|
|
ix = x
|
|
iy = y
|
|
iz = z
|
|
end
|
|
end
|
|
end
|
|
end
|
|
local index = 0
|
|
if( (ix == 0) or (ix == 3) ) then
|
|
dimension[index] = 'x'
|
|
index = index + 1
|
|
end
|
|
if( (iy == 0) or (iy == 3) ) then
|
|
dimension[index] = 'y'
|
|
index = index + 1
|
|
end
|
|
if( (iz == 0) or (iz == 3) ) then
|
|
dimension[index] = 'z'
|
|
index = index + 1
|
|
end
|
|
|
|
for k, v in pairs(dimension) do
|
|
minetest.chat_send_all( v )
|
|
if( v == 'x' ) then
|
|
for z=0, 3, 1 do
|
|
for y=0, 3, 1 do
|
|
bitmap4x4[ix][y][z] = 1
|
|
end
|
|
end
|
|
end
|
|
if( v == 'y' ) then
|
|
for x=0, 3, 1 do
|
|
for z=0, 3, 1 do
|
|
bitmap4x4[x][iy][z] = 1
|
|
end
|
|
end
|
|
end
|
|
if( v == 'z' ) then
|
|
for x=0, 3, 1 do
|
|
for y=0, 3, 1 do
|
|
bitmap4x4[x][y][iz] = 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
-- assumes you give it a bitmap of type face
|
|
util.bitmap4x4_expand_face = function( bitmap4x4 )
|
|
|
|
--find face
|
|
local ix
|
|
local iy
|
|
local iz
|
|
local dimension
|
|
for x=0, 3, 1 do
|
|
for y=0, 3, 1 do
|
|
for z=0, 3, 1 do
|
|
if( bitmap4x4[x][y][z] == 1 ) then
|
|
ix = x
|
|
iy = y
|
|
iz = z
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if( (ix == 0) or (ix == 3) ) then dimension = 'x' end
|
|
if( (iy == 0) or (iy == 3) ) then dimension = 'y' end
|
|
if( (iz == 0) or (iz == 3) ) then dimension = 'z' end
|
|
if( dimension == 'x' ) then
|
|
for z=0, 3, 1 do
|
|
for y=0, 3, 1 do
|
|
bitmap4x4[ix][y][z] = 1
|
|
end
|
|
end
|
|
end
|
|
if( dimension == 'y' ) then
|
|
for x=0, 3, 1 do
|
|
for z=0, 3, 1 do
|
|
bitmap4x4[x][iy][z] = 1
|
|
end
|
|
end
|
|
end
|
|
if( dimension == 'z' ) then
|
|
for x=0, 3, 1 do
|
|
for y=0, 3, 1 do
|
|
bitmap4x4[x][y][iz] = 1
|
|
end
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
util.bitmap4x4_expand_normal = function( bitmap4x4, normal )
|
|
--find dimension of normal that isn't 0
|
|
local dimension = ""
|
|
if( normal.x ~= 0 ) then dimension = 'x' end
|
|
if( normal.y ~= 0 ) then dimension = 'y' end
|
|
if( normal.z ~= 0 ) then dimension = 'z' end
|
|
|
|
-- find positions that are 1 and set all positions across the normal to 1
|
|
for x=0, 3, 1 do
|
|
for y=0, 3, 1 do
|
|
for z=0, 3, 1 do
|
|
if( bitmap4x4[x][y][z] == 1 ) then
|
|
if( dimension == 'x' ) then
|
|
for i=0, 3, 1 do
|
|
bitmap4x4[i][y][z] = 1
|
|
end
|
|
end
|
|
if( dimension == 'y' ) then
|
|
for i=0, 3, 1 do
|
|
bitmap4x4[x][i][z] = 1
|
|
end
|
|
end
|
|
if( dimension == 'z' ) then
|
|
for i=0, 3, 1 do
|
|
bitmap4x4[x][y][i] = 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
util.bitmap4x4_expand_edge = function( bitmap4x4 )
|
|
local print_string = ""
|
|
for i=0, 3, 1 do
|
|
for ii=0, 3, 1 do
|
|
for iii=0, 3, 1 do
|
|
print_string = print_string..bitmap4x4[i][ii][iii]
|
|
end
|
|
end
|
|
end
|
|
minetest.log( "warning", print_string )
|
|
--find index dimension not on the edge
|
|
local ix
|
|
local iy
|
|
local iz
|
|
local dimension
|
|
for x=0, 3, 1 do
|
|
for y=0, 3, 1 do
|
|
for z=0, 3, 1 do
|
|
if( bitmap4x4[x][y][z] == 1 ) then
|
|
ix = x
|
|
iy = y
|
|
iz = z
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if( (ix ~= 0) and (ix ~= 3) ) then dimension = 'x' end
|
|
if( (iy ~= 0) and (iy ~= 3) ) then dimension = 'y' end
|
|
if( (iz ~= 0) and (iz ~= 3) ) then dimension = 'z' end
|
|
|
|
if( dimension == 'x' ) then
|
|
for i=0, 3, 1 do
|
|
bitmap4x4[i][iy][iz] = 1
|
|
end
|
|
end
|
|
|
|
|
|
if( dimension == 'y' ) then
|
|
for i=0, 3, 1 do
|
|
bitmap4x4[ix][i][iz] = 1
|
|
end
|
|
end
|
|
|
|
|
|
if( dimension == 'z' ) then
|
|
for i=0, 3, 1 do
|
|
bitmap4x4[ix][iy][i] = 1
|
|
end
|
|
end
|
|
print_string = ""
|
|
for i=0, 3, 1 do
|
|
for ii=0, 3, 1 do
|
|
for iii=0, 3, 1 do
|
|
print_string = print_string..bitmap4x4[i][ii][iii]
|
|
end
|
|
end
|
|
end
|
|
minetest.log( "warning", print_string )
|
|
end
|
|
|
|
util.integer_to_bitmap = function( integer )
|
|
|
|
local bitmap = { [0] = nil, [7] = nil }
|
|
local value = 128
|
|
for i = 7, 0, -1 do
|
|
if(integer >= value) then
|
|
bitmap[i] = 1
|
|
integer = integer - value
|
|
else
|
|
bitmap[i] = 0
|
|
end
|
|
value = value/2
|
|
end
|
|
|
|
return bitmap
|
|
|
|
end
|
|
util.bitmap_to_integer = function( bitmap )
|
|
local integer = 0
|
|
local value = 1
|
|
for index = 0, 7, 1 do
|
|
integer = integer + (bitmap[index] * value)
|
|
value = value * 2
|
|
end
|
|
return integer
|
|
end
|
|
--TODO delete this if not used
|
|
util.mirror_bitmap_across_y = function( bitmap )
|
|
local new_array = { [0] = { [0]={}, [1]={}}, [1]={[0]={}, [1]={}} }
|
|
|
|
local max_index = 1
|
|
local my = max_index
|
|
for iy = 0, max_index, 1 do
|
|
for ix = 0, max_index, 1 do
|
|
for iz = 0, max_index, 1 do
|
|
new_array[ix][my][iz] = bitmap[ ix + (iy*2) + (iz*4) ]
|
|
end
|
|
end
|
|
my = my - 1
|
|
end
|
|
return util.array3d_to_bitmap( new_array )
|
|
|
|
end
|
|
|
|
--bitmap rotation: rotation of the 3d array that represents the bitmap
|
|
--rotates the array clockwise by 90 degress around the given axis
|
|
|
|
util.rotate_bitmap_around_plus_y = function( bitmap )
|
|
local new_bitmap = { [0] = { [0]={}, [1]={}}, [1]={[0]={}, [1]={}} }
|
|
local max_index = 1
|
|
|
|
for ix = 0, max_index, 1 do
|
|
for iy = 0, max_index, 1 do
|
|
for iz = 0, max_index, 1 do
|
|
new_bitmap[iz][iy][max_index-ix] = bitmap[ ix + (iy*2) + (iz*4) ]
|
|
end
|
|
end
|
|
end
|
|
return util.array3d_to_bitmap( new_bitmap )
|
|
end
|
|
util.rotate_bitmap_around_minus_y = function( bitmap )
|
|
local new_bitmap = { [0] = { [0]={}, [1]={}}, [1]={[0]={}, [1]={}} }
|
|
local max_index = 1
|
|
|
|
for ix = 0, max_index, 1 do
|
|
for iy = 0, max_index, 1 do
|
|
for iz = 0, max_index, 1 do
|
|
new_bitmap[max_index-iz][iy][ix] = bitmap[ ix + (iy*2) + (iz*4) ]
|
|
end
|
|
end
|
|
end
|
|
return util.array3d_to_bitmap( new_bitmap )
|
|
end
|
|
util.rotate_bitmap_around_plus_z = function( bitmap )
|
|
local new_bitmap = { [0] = { [0]={}, [1]={}}, [1]={[0]={}, [1]={}} }
|
|
local max_index = 1
|
|
|
|
for ix = 0, max_index, 1 do
|
|
for iy = 0, max_index, 1 do
|
|
for iz = 0, max_index, 1 do
|
|
new_bitmap[max_index-iy][ix][iz] = bitmap[ ix + (iy*2) + (iz*4) ]
|
|
end
|
|
end
|
|
end
|
|
return util.array3d_to_bitmap( new_bitmap )
|
|
end
|
|
util.rotate_bitmap_around_minus_z = function( bitmap )
|
|
local new_bitmap = { [0] = { [0]={}, [1]={}}, [1]={[0]={}, [1]={}} }
|
|
local max_index = 1
|
|
|
|
for ix = 0, max_index, 1 do
|
|
for iy = 0, max_index, 1 do
|
|
for iz = 0, max_index, 1 do
|
|
new_bitmap[iy][max_index-ix][iz] = bitmap[ ix + (iy*2) + (iz*4) ]
|
|
end
|
|
end
|
|
end
|
|
return util.array3d_to_bitmap( new_bitmap )
|
|
end
|
|
|
|
util.rotate_bitmap_around_plus_x = function( bitmap )
|
|
local new_bitmap = { [0] = { [0]={}, [1]={}}, [1]={[0]={}, [1]={}} }
|
|
local max_index = 1
|
|
|
|
for ix = 0, max_index, 1 do
|
|
for iy = 0, max_index, 1 do
|
|
for iz = 0, max_index, 1 do
|
|
new_bitmap[ix][max_index-iz][iy] = bitmap[ ix + (iy*2) + (iz*4) ]
|
|
end
|
|
end
|
|
end
|
|
return util.array3d_to_bitmap( new_bitmap )
|
|
end
|
|
util.rotate_bitmap_around_minus_x = function( bitmap )
|
|
local new_bitmap = { [0] = { [0]={}, [1]={}}, [1]={[0]={}, [1]={}} }
|
|
local max_index = 1
|
|
|
|
for ix = 0, max_index, 1 do
|
|
for iy = 0, max_index, 1 do
|
|
for iz = 0, max_index, 1 do
|
|
new_bitmap[ix][iz][max_index-iy] = bitmap[ ix + (iy*2) + (iz*4) ]
|
|
end
|
|
end
|
|
end
|
|
return util.array3d_to_bitmap( new_bitmap )
|
|
end
|
|
-- bitmap orientation assumes the current bitmap orientation is plus y
|
|
util.orient_bitmap_towards_plus_z = function( bitmap )
|
|
return util.rotate_bitmap_around_plus_x( bitmap )
|
|
end
|
|
util.orient_bitmap_towards_minus_z = function( bitmap )
|
|
return util.rotate_bitmap_around_minus_x( bitmap )
|
|
end
|
|
util.orient_bitmap_towards_plus_x = function( bitmap )
|
|
return util.rotate_bitmap_around_minus_z( bitmap )
|
|
end
|
|
util.orient_bitmap_towards_minus_x = function( bitmap )
|
|
return util.rotate_bitmap_around_plus_z( bitmap )
|
|
end
|
|
util.orient_bitmap_towards_minus_y = function( bitmap )
|
|
return util.rotate_bitmap_around_plus_z( util.rotate_bitmap_around_plus_z( bitmap ) )
|
|
end
|
|
|
|
util.bitmap_to_array3d = function( bitmap )
|
|
local array = { [0] = { [0]={}, [1]={}}, [1]={[0]={}, [1]={}} }
|
|
local max_index = 1
|
|
for ix = 0, max_index, 1 do
|
|
for iy = 0, max_index, 1 do
|
|
for iz = 0, max_index, 1 do
|
|
array[ix][iy][iz] = bitmap[ ix + (iy*2) + (iz*4)]
|
|
end
|
|
end
|
|
end
|
|
|
|
return array
|
|
end
|
|
|
|
util.array3d_to_bitmap = function( array )
|
|
local bitmap = {}
|
|
local max_index = 1
|
|
for ix = 0, max_index, 1 do
|
|
for iy = 0, max_index, 1 do
|
|
for iz = 0, max_index, 1 do
|
|
bitmap[ ix + (iy*2) + (iz*4) ] = array[ix][iy][iz]
|
|
end
|
|
end
|
|
end
|
|
return bitmap
|
|
end
|