nlua_vec2.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <lauxlib.h>
 
#include "naev.h"
#include "nlua_vec2.h"
 
#include "log.h"
#include "nluadef.h"
#include "collision.h"
 
/* Vector metatable methods */
static int vectorL_new( lua_State *L );
static int vectorL_newP( lua_State *L );
static int vectorL_copy( lua_State *L );
static int vectorL_tostring( lua_State *L );
static int vectorL_add__( lua_State *L );
static int vectorL_add( lua_State *L );
static int vectorL_sub__( lua_State *L );
static int vectorL_sub( lua_State *L );
static int vectorL_mul__( lua_State *L );
static int vectorL_mul( lua_State *L );
static int vectorL_div__( lua_State *L );
static int vectorL_div( lua_State *L );
static int vectorL_unm( lua_State *L );
static int vectorL_dot( lua_State *L );
static int vectorL_cross( lua_State *L );
static int vectorL_get( lua_State *L );
static int vectorL_polar( lua_State *L );
static int vectorL_set( lua_State *L );
static int vectorL_setP( lua_State *L );
static int vectorL_distance( lua_State *L );
static int vectorL_distance2( lua_State *L );
static int vectorL_mod( lua_State *L );
static int vectorL_angle( lua_State *L );
static int vectorL_normalize( lua_State *L );
static int vectorL_collideLineLine( lua_State *L );
static int vectorL_collideCircleLine( lua_State *L );
static const luaL_Reg vector_methods[] = {
   { "new", vectorL_new },
   { "newP", vectorL_newP },
   { "copy", vectorL_copy },
   { "__tostring", vectorL_tostring },
   { "__add", vectorL_add },
   { "add", vectorL_add__ },
   { "__sub", vectorL_sub },
   { "sub", vectorL_sub__ },
   { "__mul", vectorL_mul },
   { "mul", vectorL_mul__ },
   { "__div", vectorL_div },
   { "div", vectorL_div__ },
   { "__unm", vectorL_unm},
   { "dot", vectorL_dot },
   { "cross", vectorL_cross },
   { "get", vectorL_get },
   { "polar", vectorL_polar },
   { "set", vectorL_set },
   { "setP", vectorL_setP },
   { "dist", vectorL_distance },
   { "dist2", vectorL_distance2 },
   { "mod", vectorL_mod },
   { "angle", vectorL_angle },
   { "normalize", vectorL_normalize },
   { "collideLineLine", vectorL_collideLineLine },
   { "collideCircleLine", vectorL_collideCircleLine },
   {0,0}
}; 
int nlua_loadVector( nlua_env env )
{
   nlua_register(env, VECTOR_METATABLE, vector_methods, 1);
   return 0;
}
 
vec2* lua_tovector( lua_State *L, int ind )
{
   return (vec2*) lua_touserdata(L,ind);
}
vec2* luaL_checkvector( lua_State *L, int ind )
{
   if (lua_isvector(L,ind))
      return (vec2*) lua_touserdata(L,ind);
   luaL_typerror(L, ind, VECTOR_METATABLE);
   return NULL;
}
 
vec2* lua_pushvector( lua_State *L, vec2 vec )
{
   vec2 *v = (vec2*) lua_newuserdata(L, sizeof(vec2));
   *v = vec;
   luaL_getmetatable(L, VECTOR_METATABLE);
   lua_setmetatable(L, -2);
   return v;
}
 
int lua_isvector( lua_State *L, int ind )
{
   int ret;
 
   if (lua_getmetatable(L,ind)==0)
      return 0;
   lua_getfield(L, LUA_REGISTRYINDEX, VECTOR_METATABLE);
 
   ret = 0;
   if (lua_rawequal(L, -1, -2))  /* does it have the correct mt? */
      ret = 1;
 
   lua_pop(L, 2);  /* remove both metatables */
   return ret;
}
 
static int vectorL_new( lua_State *L )
{
   vec2 v;
   double x, y;
 
   if (!lua_isnoneornil(L,1))
      x = luaL_checknumber(L,1);
   else
      x = 0.;
 
   if (!lua_isnoneornil(L,2))
      y = luaL_checknumber(L,2);
   else
      y = x;
 
   vec2_cset( &v, x, y );
   lua_pushvector(L, v);
   return 1;
}
 
static int vectorL_newP( lua_State *L )
{
   vec2 v;
   double m, a;
 
   if (!lua_isnoneornil(L,1))
      m = luaL_checknumber(L, 1);
   else
      m = 0.;
 
   if (!lua_isnoneornil(L,2))
      a = luaL_checknumber(L, 2);
   else
      a = 0.;
 
   vec2_pset( &v, m, a );
   lua_pushvector(L, v);
   return 1;
}
 
static int vectorL_copy( lua_State *L )
{
   const vec2 *v = luaL_checkvector(L,1);
   lua_pushvector( L, *v );
   return 1;
}
 
static int vectorL_tostring( lua_State *L )
{
   char buf[STRMAX_SHORT];
   const vec2 *v = luaL_checkvector(L,1);
   snprintf( buf, sizeof(buf), "vec2( %g, %g )", v->x, v->y );
   lua_pushstring(L, buf);
   return 1;
}
 
static int vectorL_add( lua_State *L )
{
   vec2 vout, *v1;
   double x, y;
 
   if (lua_isnumber(L,1)) {
      x = y = lua_tonumber(L,1);
      v1 = luaL_checkvector(L,2);
   }
   else {
      /* Get self. */
      v1    = luaL_checkvector(L,1);
 
      /* Get rest of parameters. */
      if (lua_isvector(L,2)) {
         const vec2 *v2 = lua_tovector(L,2);
         x = v2->x;
         y = v2->y;
      }
      else {
         x = luaL_checknumber(L,2);
         if (!lua_isnoneornil(L,3))
            y = luaL_checknumber(L,3);
         else
            y = x;
      }
   }
 
   /* Actually add it */
   vec2_cset( &vout, v1->x + x, v1->y + y );
   lua_pushvector( L, vout );
 
   return 1;
}
static int vectorL_add__( lua_State *L )
{
   vec2 *v1;
   double x, y;
 
   /* Get self. */
   v1 = luaL_checkvector(L,1);
 
   /* Get rest of parameters. */
   if (lua_isvector(L,2)) {
      const vec2 *v2 = lua_tovector(L,2);
      x = v2->x;
      y = v2->y;
   }
   else {
      x = luaL_checknumber(L,2);
      if (!lua_isnoneornil(L,3))
         y = luaL_checknumber(L,3);
      else
         y = x;
   }
 
   /* Actually add it */
   vec2_cset( v1, v1->x + x, v1->y + y );
   lua_pushvector( L, *v1 );
 
   return 1;
}
 
static int vectorL_sub( lua_State *L )
{
   const vec2 *v1;
   vec2 vout;
   double x, y;
 
   /* Get self. */
   v1    = luaL_checkvector(L,1);
 
   /* Get rest of parameters. */
   if (lua_isvector(L,2)) {
      const vec2 *v2 = lua_tovector(L,2);
      x = v2->x;
      y = v2->y;
   }
   else {
      x = luaL_checknumber(L,2);
      if (!lua_isnoneornil(L,3))
         y = luaL_checknumber(L,3);
      else
         y = x;
   }
 
   /* Actually add it */
   vec2_cset( &vout, v1->x - x, v1->y - y );
   lua_pushvector( L, vout );
   return 1;
}
static int vectorL_sub__( lua_State *L )
{
   vec2 *v1;
   double x, y;
 
   /* Get self. */
   v1    = luaL_checkvector(L,1);
 
   /* Get rest of parameters. */
   if (lua_isvector(L,2)) {
      const vec2 *v2 = lua_tovector(L,2);
      x = v2->x;
      y = v2->y;
   }
   else {
      x = luaL_checknumber(L,2);
      if (!lua_isnoneornil(L,3))
         y = luaL_checknumber(L,3);
      else
         y = x;
   }
 
   /* Actually add it */
   vec2_cset( v1, v1->x - x, v1->y - y );
   lua_pushvector( L, *v1 );
   return 1;
}
 
static int vectorL_mul( lua_State *L )
{
   vec2 vout;
 
   if (lua_isnumber(L,1)) {
      double d = lua_tonumber(L,1);
      const vec2 *v  = luaL_checkvector(L,2);
      vec2_cset( &vout, v->x * d, v->y * d );
   }
   else {
      if (lua_isnumber(L,2)) {
         const vec2 *v  = luaL_checkvector(L,1);
         double d = lua_tonumber(L,2);
         vec2_cset( &vout, v->x * d, v->y * d );
      }
      else {
         const vec2 *v1 = luaL_checkvector(L,1);
         const vec2 *v2 = luaL_checkvector(L,2);
         vec2_cset( &vout, v1->x * v2->x, v1->y * v2->y );
      }
   }
 
   /* Actually add it */
   lua_pushvector( L, vout );
   return 1;
}
static int vectorL_mul__( lua_State *L )
{
   vec2 *v1 = luaL_checkvector(L,1);
   if (lua_isnumber(L,2)) {
      double mod = luaL_checknumber(L,2);
      vec2_cset( v1, v1->x * mod, v1->y * mod );
   }
   else {
      const vec2 *v2 = luaL_checkvector(L,2);
      vec2_cset( v1, v1->x * v2->x, v1->y * v2->y );
   }
 
   /* Actually add it */
   lua_pushvector( L, *v1 );
   return 1;
}
 
static int vectorL_div( lua_State *L )
{
   vec2 vout;
   const vec2 *v1 = luaL_checkvector(L,1);
   if (lua_isnumber(L,2)) {
      double mod = lua_tonumber(L,2);
      vec2_cset( &vout, v1->x / mod, v1->y / mod );
   }
   else {
      const vec2 *v2 = luaL_checkvector(L,2);
      vec2_cset( &vout, v1->x / v2->x, v1->y / v2->y );
   }
 
   lua_pushvector( L, vout );
   return 1;
}
static int vectorL_div__( lua_State *L )
{
   vec2 *v1 = luaL_checkvector(L,1);
   if (lua_isnumber(L,2)) {
      double mod = lua_tonumber(L,2);
      vec2_cset( v1, v1->x / mod, v1->y / mod );
   }
   else {
      const vec2 *v2 = luaL_checkvector(L,2);
      vec2_cset( v1, v1->x / v2->x, v1->y / v2->y );
   }
 
   lua_pushvector( L, *v1 );
   return 1;
}
static int vectorL_unm( lua_State *L )
{
   vec2 vout;
   const vec2 *vin = luaL_checkvector(L,1);
   vec2_cset( &vout, -vin->x, -vin->y );
   lua_pushvector( L, vout );
   return 1;
}
 
static int vectorL_dot( lua_State *L )
{
   const vec2 *a = luaL_checkvector(L,1);
   const vec2 *b = luaL_checkvector(L,2);
   lua_pushnumber( L, a->x*b->x + a->y*b->y );
   return 1;
}
 
static int vectorL_cross( lua_State *L )
{
   const vec2 *a = luaL_checkvector(L,1);
   const vec2 *b = luaL_checkvector(L,2);
   lua_pushnumber( L, a->x*b->y - a->y*b->x );
   return 1;
}
 
static int vectorL_get( lua_State *L )
{
   const vec2 *v1 = luaL_checkvector(L,1);
   /* Push the vector. */
   lua_pushnumber(L, v1->x);
   lua_pushnumber(L, v1->y);
   return 2;
}
 
static int vectorL_polar( lua_State *L )
{
   const vec2 *v1 = luaL_checkvector(L,1);
   lua_pushnumber(L, VMOD(*v1));
   lua_pushnumber(L, VANGLE(*v1));
   return 2;
}
 
static int vectorL_set( lua_State *L )
{
   vec2 *v1;
   double x, y;
 
   /* Get parameters. */
   v1 = luaL_checkvector(L,1);
   x  = luaL_checknumber(L,2);
   y  = luaL_checknumber(L,3);
 
   vec2_cset( v1, x, y );
   return 0;
}
 
static int vectorL_setP( lua_State *L )
{
   vec2 *v1;
   double m, a;
 
   /* Get parameters. */
   v1 = luaL_checkvector(L,1);
   m  = luaL_checknumber(L,2);
   a  = luaL_checknumber(L,3);
 
   vec2_pset( v1, m, a );
   return 0;
}
 
static int vectorL_distance( lua_State *L )
{
   double dist;
   const vec2 *v1 = luaL_checkvector(L,1);
 
   /* Get rest of parameters. */
   if (!lua_isnoneornil(L,2)) {
      const vec2 *v2 = luaL_checkvector(L,2);
      dist = vec2_dist(v1, v2);
   }
   else
      dist = vec2_odist(v1);
 
   /* Return the distance. */
   lua_pushnumber(L, dist);
   return 1;
}
 
static int vectorL_distance2( lua_State *L )
{
   double dist2;
   const vec2 *v1 = luaL_checkvector(L,1);
 
   /* Get rest of parameters. */
   if (!lua_isnoneornil(L,2)) {
      const vec2 *v2 = luaL_checkvector(L,2);
      dist2 = vec2_dist2(v1, v2);
   }
   else
      dist2 = vec2_odist2(v1);
 
   /* Return the distance. */
   lua_pushnumber(L, dist2);
   return 1;
}
 
static int vectorL_mod( lua_State *L )
{
   const vec2 *v = luaL_checkvector(L,1);
   lua_pushnumber(L, VMOD(*v));
   return 1;
}
 
static int vectorL_angle( lua_State *L )
{
   const vec2 *v = luaL_checkvector(L,1);
   lua_pushnumber(L, VANGLE(*v));
   return 1;
}
 
static int vectorL_normalize( lua_State *L )
{
   vec2 *v = luaL_checkvector(L,1);
   double n = luaL_optnumber(L,2,1.);
   double m = n/MAX(VMOD(*v),1e-6);
   v->x *= m;
   v->y *= m;
   lua_pushvector(L, *v);
   return 1;
}
 
static int vectorL_collideLineLine( lua_State *L )
{
   const vec2 *s1 = luaL_checkvector(L,1);
   const vec2 *e1 = luaL_checkvector(L,2);
   const vec2 *s2 = luaL_checkvector(L,3);
   const vec2 *e2 = luaL_checkvector(L,4);
   vec2 crash;
   int ret = CollideLineLine( s1->x, s1->y, e1->x, e1->y, s2->x, s2->y, e2->x, e2->y, &crash );
   lua_pushinteger( L, ret );
   lua_pushvector( L, crash );
   return 2;
}
 
static int vectorL_collideCircleLine( lua_State *L )
{
   const vec2 *center, *p1, *p2;
   vec2 crash[2];
   double radius;
 
   center = luaL_checkvector( L, 1 );
   radius = luaL_checknumber( L, 2 );
   p1     = luaL_checkvector( L, 3 );
   p2     = luaL_checkvector( L, 4 );
 
   int cnt = CollideLineCircle( p1, p2, center, radius, crash );
   if (cnt>0)
      lua_pushvector( L, crash[0] );
   if (cnt>1)
      lua_pushvector( L, crash[1] );
 
   return cnt;
}