nlua_transform.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <lauxlib.h>
 
#include "naev.h"
#include "nlua_transform.h"
 
#include "log.h"
#include "ndata.h"
#include "nluadef.h"
 
/* Transform metatable methods. */
static int transformL_eq( lua_State *L );
static int transformL_new( lua_State *L );
static int transformL_mul( lua_State *L );
static int transformL_get( lua_State *L );
static int transformL_set( lua_State *L );
static int transformL_scale( lua_State *L );
static int transformL_translate( lua_State *L );
static int transformL_rotate2d( lua_State *L );
static int transformL_ortho( lua_State *L );
static int transformL_applyPoint( lua_State *L );
static int transformL_applyDim( lua_State *L );
static const luaL_Reg transformL_methods[] = {
   { "__eq", transformL_eq },
   { "__mul", transformL_mul },
   { "get", transformL_get },
   { "set", transformL_set },
   { "new", transformL_new },
   { "scale", transformL_scale },
   { "translate", transformL_translate },
   { "rotate2d", transformL_rotate2d },
   { "ortho", transformL_ortho },
   { "applyPoint", transformL_applyPoint },
   { "applyDim", transformL_applyDim },
   {0,0}
}; 
int nlua_loadTransform( nlua_env env )
{
   nlua_register(env, TRANSFORM_METATABLE, transformL_methods, 1);
   return 0;
}
 
mat4* lua_totransform( lua_State *L, int ind )
{
   return (mat4*) lua_touserdata(L,ind);
}
mat4* luaL_checktransform( lua_State *L, int ind )
{
   if (lua_istransform(L,ind))
      return lua_totransform(L,ind);
   luaL_typerror(L, ind, TRANSFORM_METATABLE);
   return NULL;
}
mat4* lua_pushtransform( lua_State *L, mat4 transform )
{
   mat4 *t = (mat4*) lua_newuserdata(L, sizeof(mat4));
   *t = transform;
   luaL_getmetatable(L, TRANSFORM_METATABLE);
   lua_setmetatable(L, -2);
   return t;
}
int lua_istransform( lua_State *L, int ind )
{
   int ret;
 
   if (lua_getmetatable(L,ind)==0)
      return 0;
   lua_getfield(L, LUA_REGISTRYINDEX, TRANSFORM_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 transformL_eq( lua_State *L )
{
   const mat4 *t1 = luaL_checktransform(L,1);
   const mat4 *t2 = luaL_checktransform(L,2);
   lua_pushboolean( L, (memcmp( t1, t2, sizeof(mat4) )==0) );
   return 1;
}
 
static int transformL_new( lua_State *L )
{
   if (lua_istransform(L,1)) {
      const mat4 *M = lua_totransform(L,1);
      lua_pushtransform( L, *M );
   }
   else
      lua_pushtransform( L, mat4_identity() );
   return 1;
}
 
static int transformL_mul( lua_State *L )
{
   const mat4 *A = luaL_checktransform(L, 1);
   const mat4 *B = luaL_checktransform(L, 2);
   mat4 C;
   mat4_mul( &C, A, B );
   lua_pushtransform(L, C);
   return 1;
}
 
static int transformL_get( lua_State *L )
{
   mat4 *M = luaL_checktransform(L, 1);
   lua_newtable(L);              /* t */
   for (int i=0; i<4; i++) {
      lua_newtable(L);           /* t, t */
      for (int j=0; j<4; j++) {
         lua_pushnumber(L,M->m[j][i]); /* t, t, n */
         lua_rawseti(L,-2,j+1);       /* t, t */
      }
      lua_rawseti(L,-2,i+1);          /* t */
   }
   return 1;
}
 
static int transformL_set( lua_State *L )
{
   mat4 *M  = luaL_checktransform(L, 1);
   int i    = luaL_checkinteger(L, 2)-1;
   int j    = luaL_checkinteger(L, 3)-1;
   double v = luaL_checknumber(L, 4);
#if DEBUGGING
   if (i < 0 || i > 3) {
      WARN(_("Matrix column value not in range: %d"),i);
      i = CLAMP(0,3,i);
   }
   if (j < 0 || j > 3) {
      WARN(_("Matrix row value not in range: %d"),j);
      j = CLAMP(0,3,j);
   }
#endif /* DEBUGGING */
   M->m[i][j] = v;
   return 0;
}
 
static int transformL_scale( lua_State *L )
{
   const mat4 *M = luaL_checktransform(L, 1);
   double x = luaL_checknumber(L,2);
   double y = luaL_checknumber(L,3);
   double z = luaL_optnumber(L,4,1.);
   mat4 out = *M;
   mat4_scale( &out, x, y, z );
   lua_pushtransform(L, out);
   return 1;
}
 
static int transformL_translate( lua_State *L )
{
   const mat4 *M = luaL_checktransform(L, 1);
   double x = luaL_checknumber(L,2);
   double y = luaL_checknumber(L,3);
   double z = luaL_optnumber(L,4,0.);
   mat4 out = *M;
   mat4_translate( &out, x, y, z );
   lua_pushtransform(L, out);
   return 1;
}
 
static int transformL_rotate2d( lua_State *L )
{
   const mat4 *M = luaL_checktransform(L, 1);
   double a = luaL_checknumber(L,2);
   mat4 out = *M;
   mat4_rotate2d( &out, a );
   lua_pushtransform(L, out);
   return 1;
}
 
static int transformL_ortho( lua_State *L )
{
   double left    = luaL_checknumber(L,1);
   double right   = luaL_checknumber(L,2);
   double bottom  = luaL_checknumber(L,3);
   double top     = luaL_checknumber(L,4);
   double nearVal = luaL_checknumber(L,5);
   double farVal  = luaL_checknumber(L,6);
   lua_pushtransform(L, mat4_ortho(left, right, bottom, top, nearVal, farVal) );
   return 1;
}
 
static int transformL_applyPoint( lua_State *L )
{
   double gp[3], p[3];
   mat4 *M = luaL_checktransform(L, 1);
   gp[0] = luaL_checknumber(L,2);
   gp[1] = luaL_checknumber(L,3);
   gp[2] = luaL_checknumber(L,4);
 
   for (int i=0; i<3; i++)
      p[i] = M->m[0][i]*gp[0] + M->m[1][i]*gp[1] + M->m[2][i]*gp[2] + M->m[3][i];
 
   lua_pushnumber(L, p[0]);
   lua_pushnumber(L, p[1]);
   lua_pushnumber(L, p[2]);
   return 3;
}
 
static int transformL_applyDim( lua_State *L )
{
   double gp[3], p[3];
   mat4 *M = luaL_checktransform(L, 1);
   gp[0] = luaL_checknumber(L,2);
   gp[1] = luaL_checknumber(L,3);
   gp[2] = luaL_checknumber(L,4);
 
   for (int i=0; i<3; i++)
      p[i] = M->m[0][i]*gp[0] + M->m[1][i]*gp[1] + M->m[2][i]*gp[2];
 
   lua_pushnumber(L, p[0]);
   lua_pushnumber(L, p[1]);
   lua_pushnumber(L, p[2]);
   return 3;
}