builtin/game/voxelarea.lua

   1 VoxelArea = {
   2         MinEdge = {x=1, y=1, z=1},
   3         MaxEdge = {x=0, y=0, z=0},
   4         ystride = 0,
   5         zstride = 0,
   6 }
   7
   8 function VoxelArea:new(o)
   9         o = o or {}
  10         setmetatable(o, self)
  11         self.__index = self
  12
  13         local e = o:getExtent()
  14         o.ystride = e.x
  15         o.zstride = e.x * e.y
  16
  17         return o
  18 end
  19
  20 function VoxelArea:getExtent()
  21         local MaxEdge, MinEdge = self.MaxEdge, self.MinEdge
  22         return {
  23                 x = MaxEdge.x - MinEdge.x + 1,
  24                 y = MaxEdge.y - MinEdge.y + 1,
  25                 z = MaxEdge.z - MinEdge.z + 1,
  26         }
  27 end
  28
  29 function VoxelArea:getVolume()
  30         local e = self:getExtent()
  31         return e.x * e.y * e.z
  32 end
  33
  34 function VoxelArea:index(x, y, z)
  35         local MinEdge = self.MinEdge
  36         local i = (z - MinEdge.z) * self.zstride +
  37                           (y - MinEdge.y) * self.ystride +
  38                           (x - MinEdge.x) + 1
  39         return math.floor(i)
  40 end
  41
  42 function VoxelArea:indexp(p)
  43         local MinEdge = self.MinEdge
  44         local i = (p.z - MinEdge.z) * self.zstride +
  45                           (p.y - MinEdge.y) * self.ystride +
  46                           (p.x - MinEdge.x) + 1
  47         return math.floor(i)
  48 end
  49
  50 function VoxelArea:position(i)
  51         local p = {}
  52         local MinEdge = self.MinEdge
  53
  54         i = i - 1
  55
  56         p.z = math.floor(i / self.zstride) + MinEdge.z
  57         i = i % self.zstride
  58
  59         p.y = math.floor(i / self.ystride) + MinEdge.y
  60         i = i % self.ystride
  61
  62         p.x = math.floor(i) + MinEdge.x
  63
  64         return p
  65 end
  66
  67 function VoxelArea:contains(x, y, z)
  68         local MaxEdge, MinEdge = self.MaxEdge, self.MinEdge
  69         return (x >= MinEdge.x) and (x <= MaxEdge.x) and
  70                    (y >= MinEdge.y) and (y <= MaxEdge.y) and
  71                    (z >= MinEdge.z) and (z <= MaxEdge.z)
  72 end
  73
  74 function VoxelArea:containsp(p)
  75         local MaxEdge, MinEdge = self.MaxEdge, self.MinEdge
  76         return (p.x >= MinEdge.x) and (p.x <= MaxEdge.x) and
  77                    (p.y >= MinEdge.y) and (p.y <= MaxEdge.y) and
  78                    (p.z >= MinEdge.z) and (p.z <= MaxEdge.z)
  79 end
  80
  81 function VoxelArea:containsi(i)
  82         return (i >= 1) and (i <= self:getVolume())
  83 end
  84
  85 function VoxelArea:iter(minx, miny, minz, maxx, maxy, maxz)
  86         local i = self:index(minx, miny, minz) - 1
  87         local last = self:index(maxx, maxy, maxz)
  88         local ystride = self.ystride
  89         local zstride = self.zstride
  90         local yoff = (last+1) % ystride
  91         local zoff = (last+1) % zstride
  92         local ystridediff = (i - last) % ystride
  93         local zstridediff = (i - last) % zstride
  94         return function()
  95                 i = i + 1
  96                 if i % zstride == zoff then
  97                         i = i + zstridediff
  98                 elseif i % ystride == yoff then
  99                         i = i + ystridediff
 100                 end
 101                 if i <= last then
 102                         return i
 103                 end
 104         end
 105 end
 106
 107 function VoxelArea:iterp(minp, maxp)
 108         return self:iter(minp.x, minp.y, minp.z, maxp.x, maxp.y, maxp.z)
 109 end