nlua_tex.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include "SDL_image.h"
#include <lauxlib.h>
 
#include "physfsrwops.h"
 
#include "nlua_tex.h"
 
#include "ndata.h"
#include "nlua_data.h"
#include "nlua_file.h"
#include "nluadef.h"
#include "physics.h"
 
static int nlua_tex_counter = 0;
 
/* Helpers. */
static inline uint32_t get_pixel( SDL_Surface *surface, int x, int y );
 
/* Texture metatable methods. */
static int texL_close( lua_State *L );
static int texL_new( lua_State *L );
static int texL_readData( lua_State *L );
static int texL_writeData( lua_State *L );
static int texL_dim( lua_State *L );
static int texL_sprites( lua_State *L );
static int texL_spriteFromDir( lua_State *L );
static int texL_setFilter( lua_State *L );
static int texL_setWrap( lua_State *L );
 
static const luaL_Reg texL_methods[] = {
   { "__gc", texL_close },
   { "new", texL_new },
   { "open", texL_new },
   { "readData", texL_readData },
   { "writeData", texL_writeData },
   { "dim", texL_dim },
   { "sprites", texL_sprites },
   { "spriteFromDir", texL_spriteFromDir },
   { "setFilter", texL_setFilter },
   { "setWrap", texL_setWrap },
   { 0, 0 } }; 

int nlua_loadTex( nlua_env env )
{
   nlua_register( env, TEX_METATABLE, texL_methods, 1 );
   return 0;
}

glTexture *lua_totex( lua_State *L, int ind )
{
   return *( (glTexture **)lua_touserdata( L, ind ) );
}

glTexture *luaL_checktex( lua_State *L, int ind )
{
   if ( lua_istex( L, ind ) )
      return lua_totex( L, ind );
   luaL_typerror( L, ind, TEX_METATABLE );
   return NULL;
}

glTexture *luaL_validtex( lua_State *L, int ind, const char *searchpath )
{
   char path[PATH_MAX];
   if ( lua_istex( L, ind ) )
      return gl_dupTexture( luaL_checktex( L, ind ) );
   ndata_getPathDefault( path, sizeof( path ), searchpath,
                         luaL_checkstring( L, ind ) );
   return gl_newImage( path, 0 );
}

glTexture **lua_pushtex( lua_State *L, glTexture *texture )
{
   glTexture **t = (glTexture **)lua_newuserdata( L, sizeof( glTexture * ) );
   *t            = texture;
   luaL_getmetatable( L, TEX_METATABLE );
   lua_setmetatable( L, -2 );
   return t;
}

int lua_istex( lua_State *L, int ind )
{
   int ret;
 
   if ( lua_getmetatable( L, ind ) == 0 )
      return 0;
   lua_getfield( L, LUA_REGISTRYINDEX, TEX_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 texL_close( lua_State *L )
{
   gl_freeTexture( luaL_checktex( L, 1 ) );
   if ( gl_checkErr() )
      NLUA_ERROR( L, _( "OpenGL Error!" ) );
   return 0;
}

static int texL_new( lua_State *L )
{
   const char *path;
   glTexture  *tex;
   LuaFile_t  *lf;
   LuaData_t  *ld;
   int         sx, sy;
   SDL_RWops  *rw;
   char       *name;
 
   /* Defaults. */
   lf   = NULL;
   ld   = NULL;
   path = NULL;
 
   /* Get path. */
   if ( lua_isdata( L, 1 ) ) {
      int w, h;
      ld = luaL_checkdata( L, 1 );
      /* Since we don't know the size we need the width and height separately.
       */
      w = luaL_checkinteger( L, 2 );
      h = luaL_checkinteger( L, 3 );
      if ( ( w < 0 ) || ( h < 0 ) )
         return NLUA_ERROR( L, _( "Texture dimensions must be positive" ) );
      sx = luaL_optinteger( L, 4, 1 );
      sy = luaL_optinteger( L, 5, 1 );
      if ( ( sx < 0 ) || ( sy < 0 ) )
         return NLUA_ERROR( L, _( "Spritesheet dimensions must be positive" ) );
      if ( ld->type != LUADATA_NUMBER )
         return NLUA_ERROR( L, _( "Data has invalid type for texture" ) );
      if ( w * h * ld->elem * 4 != ld->size )
         return NLUA_ERROR( L,
                            _( "Texture dimensions don't match data size!" ) );
      SDL_asprintf( &name, "nlua_texture_%03d", ++nlua_tex_counter );
      tex = gl_loadImageData( (void *)ld->data, w, h, sx, sy, name );
      free( name );
      if ( tex == NULL )
         return 0;
      lua_pushtex( L, tex );
      return 1;
   } else if ( lua_isfile( L, 1 ) )
      lf = luaL_checkfile( L, 1 );
   else
      path = luaL_checkstring( L, 1 );
 
   sx = luaL_optinteger( L, 2, 1 );
   sy = luaL_optinteger( L, 3, 1 );
   if ( ( sx < 0 ) || ( sy < 0 ) )
      return NLUA_ERROR( L, _( "Spritesheet dimensions must be positive" ) );
 
   /* Push new texture. */
   if ( path != NULL )
      tex = gl_newSprite( path, sx, sy, 0 );
   else {
      rw = PHYSFSRWOPS_openRead( lf->path );
      if ( rw == NULL )
         return NLUA_ERROR( L, "Unable to open '%s'", lf->path );
      tex = gl_newSpriteRWops( lf->path, rw, sx, sy, 0 );
      SDL_RWclose( rw );
   }
 
   /* Failed to load. */
   if ( tex == NULL )
      return 0;
   /* Properly loaded. */
   lua_pushtex( L, tex );
   return 1;
}
 
static inline uint32_t get_pixel( SDL_Surface *surface, int x, int y )
{
   int bpp = surface->format->BytesPerPixel;
   /* Here p is the address to the pixel we want to retrieve */
   uint8_t *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
 
   switch ( bpp ) {
   case 1:
      return *p;
      break;
 
   case 2:
      return *(Uint16 *)p;
      break;
 
   case 3:
      if ( SDL_BYTEORDER == SDL_BIG_ENDIAN )
         return p[0] << 16 | p[1] << 8 | p[2];
      else
         return p[0] | p[1] << 8 | p[2] << 16;
      break;
 
   case 4:
      return *(Uint32 *)p;
      break;
 
   default:
      return 0; /* shouldn't happen, but avoids warnings */
   }
}

static int texL_readData( lua_State *L )
{
   LuaFile_t   *lf;
   LuaData_t    ld;
   SDL_Surface *surface;
   SDL_RWops   *rw;
   const char  *s;
   size_t       size;
   uint8_t      r, g, b, a;
   uint32_t     pix;
   float       *data;
 
   s = NULL;
   if ( lua_isfile( L, 1 ) ) {
      lf = luaL_checkfile( L, 1 );
      s  = lf->path;
   } else
      s = luaL_checkstring( L, 1 );
   rw = PHYSFSRWOPS_openRead( s );
   if ( rw == NULL )
      return NLUA_ERROR( L, _( "problem opening file '%s' for reading" ), s );
 
   /* Try to read the image. */
   surface = IMG_Load_RW( rw, 1 );
   if ( surface == NULL )
      return NLUA_ERROR( L, _( "problem opening image for reading" ) );
 
   /* Convert surface to LuaData_t */
   SDL_LockSurface( surface );
   size    = surface->w * surface->h;
   ld.elem = sizeof( float );
   ld.size = ld.elem * size * 4;
   ld.data = calloc( ld.elem * 4, size );
   ld.type = LUADATA_NUMBER;
   data    = (float *)ld.data;
   for ( int i = 0; i < surface->h; i++ ) {
      for ( int j = 0; j < surface->w; j++ ) {
         pix = get_pixel( surface, j, i );
         SDL_GetRGBA( pix, surface->format, &r, &g, &b, &a );
         size_t pos    = 4 * ( ( surface->h - i - 1 ) * surface->w + j );
         data[pos + 0] = ( (float)r ) / 255.;
         data[pos + 1] = ( (float)g ) / 255.;
         data[pos + 2] = ( (float)b ) / 255.;
         data[pos + 3] = ( (float)a ) / 255.;
      }
   }
   SDL_UnlockSurface( surface );
 
   /* Return parameters. */
   lua_pushdata( L, ld );
   lua_pushinteger( L, surface->w );
   lua_pushinteger( L, surface->h );
 
   /* Clean up. */
   SDL_FreeSurface( surface );
 
   return 3;
}

static int texL_writeData( lua_State *L )
{
   glTexture   *tex      = luaL_checktex( L, 1 );
   const char  *filename = luaL_checkstring( L, 2 );
   int          w, h;
   size_t       len;
   char        *data;
   SDL_Surface *surface;
   SDL_RWops   *rw;
 
   w    = tex->w;
   h    = tex->h;
   len  = w * h * 4 * sizeof( GLubyte );
   data = malloc( len );
 
   /* Read raw data. */
   glBindTexture( GL_TEXTURE_2D, tex->texture );
   glGetTexImage( GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
   if ( gl_checkErr() )
      NLUA_ERROR( L, _( "OpenGL Error!" ) );
 
   /* Convert to PNG. */
   surface = SDL_CreateRGBSurface( 0, w, h, 32, RGBAMASK );
   for ( int i = 0; i < h; i++ )
      memcpy( (GLubyte *)surface->pixels + i * ( 4 * w ),
              &data[( h - i - 1 ) * ( 4 * w )], 4 * w );
 
   /* Free buffer. */
   free( data );
 
   /* Save to file. */
   if ( !( rw = PHYSFSRWOPS_openWrite( filename ) ) )
      return NLUA_ERROR( L, _( "Unable to open '%s' for writing!" ), filename );
   else
      IMG_SavePNG_RW( surface, rw, 1 );
 
   SDL_FreeSurface( surface );
 
   lua_pushboolean( L, 1 );
   return 1;
}

static int texL_dim( lua_State *L )
{
   const glTexture *tex = luaL_checktex( L, 1 );
   /* Get all 4 values. */
   lua_pushnumber( L, tex->w );
   lua_pushnumber( L, tex->h );
   lua_pushnumber( L, tex->sw );
   lua_pushnumber( L, tex->sh );
   return 4;
}

static int texL_sprites( lua_State *L )
{
   const glTexture *tex = luaL_checktex( L, 1 );
   /* Get sprites. */
   lua_pushnumber( L, tex->sx * tex->sy );
   lua_pushnumber( L, tex->sx );
   lua_pushnumber( L, tex->sy );
   return 3;
}

static int texL_spriteFromDir( lua_State *L )
{
 
   int              sx, sy;
   const glTexture *tex = luaL_checktex( L, 1 );
   double           a   = luaL_checknumber( L, 2 );
 
   /* Calculate with parameter validity.. */
   gl_getSpriteFromDir( &sx, &sy, tex->sx, tex->sy, angle_clean( a ) );
 
   /* Return. */
   lua_pushinteger( L, sx + 1 );
   lua_pushinteger( L, sy + 1 );
   return 2;
}

static int texL_setFilter( lua_State *L )
{
   const glTexture *tex  = luaL_checktex( L, 1 );
   const char      *smin = luaL_checkstring( L, 2 );
   const char      *smag = luaL_optstring( L, 3, smin );
   GLint            min, mag;
 
   min = gl_stringToFilter( smin );
   mag = gl_stringToFilter( smag );
 
   if ( min == 0 || mag == 0 )
      NLUA_INVALID_PARAMETER( L, 2 );
 
   glBindTexture( GL_TEXTURE_2D, tex->texture );
   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag );
   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min );
   if ( gl_checkErr() )
      NLUA_ERROR( L, _( "OpenGL Error!" ) );
 
   return 0;
}

static int texL_setWrap( lua_State *L )
{
   const glTexture *tex    = luaL_checktex( L, 1 );
   const char      *shoriz = luaL_checkstring( L, 2 );
   const char      *svert  = luaL_optstring( L, 3, shoriz );
   const char      *sdepth = luaL_optstring( L, 4, shoriz );
   GLint            horiz, vert, depth;
 
   horiz = gl_stringToClamp( shoriz );
   vert  = gl_stringToClamp( svert );
   depth = gl_stringToClamp( sdepth );
 
   if ( horiz == 0 || vert == 0 || depth == 0 )
      NLUA_INVALID_PARAMETER( L, 2 );
 
   glBindTexture( GL_TEXTURE_2D, tex->texture );
   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, horiz );
   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, vert );
   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, depth );
   if ( gl_checkErr() )
      NLUA_ERROR( L, _( "OpenGL Error!" ) );
 
   return 0;
}