builtin/vector.lua

   1
   2 vector = {}
   3
   4 local function assert_vector(v)
   5         assert(type(v) == "table" and v.x and v.y and v.z, "Invalid vector")
   6 end
   7
   8 function vector.new(a, b, c)
   9         if type(a) == "table" then
  10                 assert(a.x and a.y and a.z, "Invalid vector passed to vector.new()")
  11                 return {x=a.x, y=a.y, z=a.z}
  12         elseif a then
  13                 assert(b and c, "Invalid arguments for vector.new()")
  14                 return {x=a, y=b, z=c}
  15         end
  16         return {x=0, y=0, z=0}
  17 end
  18
  19 function vector.equals(a, b)
  20         assert_vector(a)
  21         assert_vector(b)
  22         return a.x == b.x and
  23                a.y == b.y and
  24                a.z == b.z
  25 end
  26
  27 function vector.length(v)
  28         assert_vector(v)
  29         return math.hypot(v.x, math.hypot(v.y, v.z))
  30 end
  31
  32 function vector.normalize(v)
  33         assert_vector(v)
  34         local len = vector.length(v)
  35         if len == 0 then
  36                 return {x=0, y=0, z=0}
  37         else
  38                 return vector.divide(v, len)
  39         end
  40 end
  41
  42 function vector.round(v)
  43         assert_vector(v)
  44         return {
  45                 x = math.floor(v.x + 0.5),
  46                 y = math.floor(v.y + 0.5),
  47                 z = math.floor(v.z + 0.5)
  48         }
  49 end
  50
  51 function vector.distance(a, b)
  52         assert_vector(a)
  53         assert_vector(b)
  54         local x = a.x - b.x
  55         local y = a.y - b.y
  56         local z = a.z - b.z
  57         return math.hypot(x, math.hypot(y, z))
  58 end
  59
  60 function vector.direction(pos1, pos2)
  61         assert_vector(pos1)
  62         assert_vector(pos2)
  63         local x_raw = pos2.x - pos1.x
  64         local y_raw = pos2.y - pos1.y
  65         local z_raw = pos2.z - pos1.z
  66         local x_abs = math.abs(x_raw)
  67         local y_abs = math.abs(y_raw)
  68         local z_abs = math.abs(z_raw)
  69         if x_abs >= y_abs and
  70            x_abs >= z_abs then
  71                 y_raw = y_raw * (1 / x_abs)
  72                 z_raw = z_raw * (1 / x_abs)
  73                 x_raw = x_raw / x_abs
  74         end
  75         if y_abs >= x_abs and
  76            y_abs >= z_abs then
  77                 x_raw = x_raw * (1 / y_abs)
  78                 z_raw = z_raw * (1 / y_abs)
  79                 y_raw = y_raw / y_abs
  80         end
  81         if z_abs >= y_abs and
  82            z_abs >= x_abs then
  83                 x_raw = x_raw * (1 / z_abs)
  84                 y_raw = y_raw * (1 / z_abs)
  85                 z_raw = z_raw / z_abs
  86         end
  87         return {x=x_raw, y=y_raw, z=z_raw}
  88 end
  89
  90
  91 function vector.add(a, b)
  92         assert_vector(a)
  93         if type(b) == "table" then
  94             assert_vector(b)
  95                 return {x = a.x + b.x,
  96                         y = a.y + b.y,
  97                         z = a.z + b.z}
  98         else
  99                 return {x = a.x + b,
 100                         y = a.y + b,
 101                         z = a.z + b}
 102         end
 103 end
 104
 105 function vector.subtract(a, b)
 106         assert_vector(a)
 107         if type(b) == "table" then
 108             assert_vector(b)
 109                 return {x = a.x - b.x,
 110                         y = a.y - b.y,
 111                         z = a.z - b.z}
 112         else
 113                 return {x = a.x - b,
 114                         y = a.y - b,
 115                         z = a.z - b}
 116         end
 117 end
 118
 119 function vector.multiply(a, b)
 120         assert_vector(a)
 121         if type(b) == "table" then
 122             assert_vector(b)
 123                 return {x = a.x * b.x,
 124                         y = a.y * b.y,
 125                         z = a.z * b.z}
 126         else
 127                 return {x = a.x * b,
 128                         y = a.y * b,
 129                         z = a.z * b}
 130         end
 131 end
 132
 133 function vector.divide(a, b)
 134         assert_vector(a)
 135         if type(b) == "table" then
 136         assert_vector(b)
 137                 return {x = a.x / b.x,
 138                         y = a.y / b.y,
 139                         z = a.z / b.z}
 140         else
 141                 return {x = a.x / b,
 142                         y = a.y / b,
 143                         z = a.z / b}
 144         end
 145 end
 146