nlua_colour.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <lauxlib.h>
 
#include "naev.h"
#include "nlua_colour.h"
 
#include "log.h"
#include "nluadef.h"
 
/* Colour metatable methods. */
static int colL_eq( lua_State *L );
static int colL_tostring( lua_State * L );
static int colL_new( lua_State *L );
static int colL_alpha( lua_State *L );
static int colL_rgb( lua_State *L );
static int colL_hsv( lua_State *L );
static int colL_setrgb( lua_State *L );
static int colL_sethsv( lua_State *L );
static int colL_setalpha( lua_State *L );
static int colL_linearToGamma( lua_State *L );
static int colL_gammaToLinear( lua_State *L );
static const luaL_Reg colL_methods[] = {
   { "__eq", colL_eq },
   { "__tostring", colL_tostring },
   { "new", colL_new },
   { "alpha", colL_alpha },
   { "rgb", colL_rgb },
   { "hsv", colL_hsv },
   { "setRGB", colL_setrgb },
   { "setHSV", colL_sethsv },
   { "setAlpha", colL_setalpha },
   { "linearToGamma", colL_linearToGamma },
   { "gammaToLinear", colL_gammaToLinear },
   {0,0}
}; 
int nlua_loadCol( nlua_env env )
{
   nlua_register(env, COL_METATABLE, colL_methods, 1);
   return 0;
}
 
glColour* lua_tocolour( lua_State *L, int ind )
{
   return (glColour*) lua_touserdata(L,ind);
}
glColour* luaL_checkcolour( lua_State *L, int ind )
{
   if (lua_iscolour(L,ind))
      return lua_tocolour(L,ind);
   luaL_typerror(L, ind, COL_METATABLE);
   return NULL;
}
glColour* lua_pushcolour( lua_State *L, glColour colour )
{
   glColour *c = (glColour*) lua_newuserdata(L, sizeof(glColour));
   *c = colour;
   luaL_getmetatable(L, COL_METATABLE);
   lua_setmetatable(L, -2);
   return c;
}
int lua_iscolour( lua_State *L, int ind )
{
   int ret;
 
   if (lua_getmetatable(L,ind)==0)
      return 0;
   lua_getfield(L, LUA_REGISTRYINDEX, COL_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 colL_eq( lua_State *L )
{
   glColour *c1, *c2;
   c1 = luaL_checkcolour(L,1);
   c2 = luaL_checkcolour(L,2);
   lua_pushboolean( L, (memcmp( c1, c2, sizeof(glColour) )==0) );
   return 1;
}
 
static int colL_tostring( lua_State * L )
{
   const glColour *col = luaL_checkcolour(L,1);
   char buf[STRMAX_SHORT];
   snprintf( buf, sizeof(buf), "Colour( %.2f, %.2f, %.2f, %.2f )", col->r, col->g, col->b, col->a );
   lua_pushstring( L, buf );
   return 1;
}
 
static int colL_new( lua_State *L )
{
   glColour col;
   const glColour *col2;
 
   if (lua_gettop(L)==0) {
      col.r = col.g = col.b = col.a = 1.;
   }
   else if (lua_isnumber(L,1)) {
      col.r = gammaToLinear(luaL_checknumber(L,1));
      col.g = gammaToLinear(luaL_checknumber(L,2));
      col.b = gammaToLinear(luaL_checknumber(L,3));
      col.a = luaL_optnumber(L,4,1.);
   }
   else if (lua_isstring(L,1)) {
      col2 = col_fromName( lua_tostring(L,1) );
      if (col2 == NULL) {
         return NLUA_ERROR( L, _("Colour '%s' does not exist!"), lua_tostring(L,1) );
         return 0;
      }
      col = *col2;
      col.a = luaL_optnumber(L,2,1.);
   }
   else if (lua_iscolour(L,1))
      col = *lua_tocolour(L,1);
   else
      NLUA_INVALID_PARAMETER(L,1);
 
   lua_pushcolour( L, col );
   return 1;
}
 
static int colL_alpha( lua_State *L )
{
   glColour *col = luaL_checkcolour(L,1);
   lua_pushnumber( L, col->a );
   return 1;
}
 
static int colL_rgb( lua_State *L )
{
   glColour *col = luaL_checkcolour(L,1);
   if (lua_toboolean(L,2)) {
      lua_pushnumber( L, linearToGamma( col->r ) );
      lua_pushnumber( L, linearToGamma( col->g ) );
      lua_pushnumber( L, linearToGamma( col->b ) );
   }
   else {
      lua_pushnumber( L, col->r );
      lua_pushnumber( L, col->g );
      lua_pushnumber( L, col->b );
   }
   return 3;
}
 
static int colL_hsv( lua_State *L )
{
   float h, s, v, r, g, b;
   const glColour *col = luaL_checkcolour(L,1);
   if (lua_toboolean(L,2)) {
      r = linearToGamma( col->r );
      g = linearToGamma( col->g );
      b = linearToGamma( col->b );
   }
   else {
      r = col->r;
      g = col->g;
      b = col->b;
   }
   col_rgb2hsv( &h, &s, &v, r, g, b );
   lua_pushnumber( L, h );
   lua_pushnumber( L, s );
   lua_pushnumber( L, v );
   return 3;
}
 
static int colL_setrgb( lua_State *L )
{
   glColour *col = luaL_checkcolour(L,1);
   col->r  = luaL_checknumber(L,2);
   col->g  = luaL_checknumber(L,3);
   col->b  = luaL_checknumber(L,4);
   return 0;
}
 
static int colL_sethsv( lua_State *L )
{
   float h, s, v;
   glColour *col = luaL_checkcolour(L,1);
   h  = luaL_checknumber(L,2);
   s  = luaL_checknumber(L,3);
   v  = luaL_checknumber(L,4);
   col_hsv2rgb( col, h, s, v );
   return 0;
}
 
static int colL_setalpha( lua_State *L )
{
   glColour *col = luaL_checkcolour(L,1);
   col->a = luaL_checknumber(L,2);
   return 0;
}
 
static int colL_linearToGamma( lua_State *L )
{
   const glColour *col = luaL_checkcolour(L,1);
   glColour out;
   out.r = linearToGamma( col->r );
   out.g = linearToGamma( col->g );
   out.b = linearToGamma( col->b );
   out.a = col->a;
   lua_pushcolour(L,out);
   return 1;
}
 
static int colL_gammaToLinear( lua_State *L )
{
   const glColour *col = luaL_checkcolour(L,1);
   glColour out;
   out.r = gammaToLinear( col->r );
   out.g = gammaToLinear( col->g );
   out.b = gammaToLinear( col->b );
   out.a = col->a;
   lua_pushcolour(L,out);
   return 1;
}