nlua_shader.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <lauxlib.h>
 
#include "nlua_shader.h"
 
#include "array.h"
#include "nlua_tex.h"
#include "nluadef.h"
#include "render.h"
 
/* Shader metatable methods. */
static int shaderL_gc( lua_State *L );
static int shaderL_eq( lua_State *L );
static int shaderL_new( lua_State *L );
static int shaderL_send( lua_State *L );
static int shaderL_sendRaw( lua_State *L );
static int shaderL_hasUniform( lua_State *L );
static int shaderL_addPostProcess( lua_State *L );
static int shaderL_rmPostProcess( lua_State *L );
 
static const luaL_Reg shaderL_methods[] = {
   { "__gc", shaderL_gc },
   { "__eq", shaderL_eq },
   { "new", shaderL_new },
   { "send", shaderL_send },
   { "sendRaw", shaderL_sendRaw },
   { "hasUniform", shaderL_hasUniform },
   { "addPPShader", shaderL_addPostProcess },
   { "rmPPShader", shaderL_rmPostProcess },
   { 0, 0 } }; 
 
/* Useful stuff. */
static int           shader_compareUniform( const void *a, const void *b );
static int           shader_searchUniform( const void *id, const void *u );
static LuaUniform_t *shader_getUniform( const LuaShader_t *ls,
                                        const char        *name );
static int           shaderL_sendHelper( lua_State *L, int ignore_missing );

int nlua_loadShader( nlua_env env )
{
   nlua_register( env, SHADER_METATABLE, shaderL_methods, 1 );
   return 0;
}

LuaShader_t *lua_toshader( lua_State *L, int ind )
{
   return (LuaShader_t *)lua_touserdata( L, ind );
}

LuaShader_t *luaL_checkshader( lua_State *L, int ind )
{
   if ( lua_isshader( L, ind ) )
      return lua_toshader( L, ind );
   luaL_typerror( L, ind, SHADER_METATABLE );
   return NULL;
}

LuaShader_t *lua_pushshader( lua_State *L, LuaShader_t shader )
{
   LuaShader_t *c = (LuaShader_t *)lua_newuserdata( L, sizeof( LuaShader_t ) );
   *c             = shader;
   luaL_getmetatable( L, SHADER_METATABLE );
   lua_setmetatable( L, -2 );
   return c;
}

int lua_isshader( lua_State *L, int ind )
{
   int ret;
 
   if ( lua_getmetatable( L, ind ) == 0 )
      return 0;
   lua_getfield( L, LUA_REGISTRYINDEX, SHADER_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 shaderL_gc( lua_State *L )
{
   LuaShader_t *shader = luaL_checkshader( L, 1 );
   if ( shader->pp_id > 0 )
      render_postprocessRm( shader->pp_id );
   glDeleteProgram( shader->program );
   array_free( shader->tex );
   free( shader->uniforms );
   if ( gl_checkErr() )
      NLUA_ERROR( L, _( "OpenGL Error!" ) );
   return 0;
}

static int shaderL_eq( lua_State *L )
{
   const LuaShader_t *f1, *f2;
   f1 = luaL_checkshader( L, 1 );
   f2 = luaL_checkshader( L, 2 );
   lua_pushboolean( L, ( memcmp( f1, f2, sizeof( LuaShader_t ) ) == 0 ) );
   return 1;
}
 
/*
 * For qsort.
 */
static int shader_compareUniform( const void *a, const void *b )
{
   const LuaUniform_t *u1, *u2;
   u1 = (const LuaUniform_t *)a;
   u2 = (const LuaUniform_t *)b;
   return strcmp( u1->name, u2->name );
}
 
static int shader_searchUniform( const void *id, const void *u )
{
   return strcmp( (const char *)id, ( (LuaUniform_t *)u )->name );
}
 
static LuaUniform_t *shader_getUniform( const LuaShader_t *ls,
                                        const char        *name )
{
   return bsearch( name, ls->uniforms, ls->nuniforms, sizeof( LuaUniform_t ),
                   shader_searchUniform );
}

static int shaderL_new( lua_State *L )
{
   LuaShader_t shader;
   const char *pixelcode, *vertexcode;
   GLint       ntex;
   GLsizei     length;
 
   /* Get arguments. */
   pixelcode  = luaL_checkstring( L, 1 );
   vertexcode = luaL_checkstring( L, 2 );
 
   /* Initialize. */
   memset( &shader, 0, sizeof( shader ) );
 
   /* Do from string. */
   shader.program = gl_program_vert_frag_string(
      vertexcode, strlen( vertexcode ), pixelcode, strlen( pixelcode ) );
   if ( shader.program == 0 )
      return NLUA_ERROR( L, _( "shader failed to compile!" ) );
 
      /* Set up defaults. */
#define ATTRIB( name )                                                         \
   shader.name = glGetAttribLocation( shader.program, #name )
#define UNIFORM( name )                                                        \
   shader.name = glGetUniformLocation( shader.program, #name )
   UNIFORM( ViewSpaceFromLocal );
   UNIFORM( ClipSpaceFromView );
   UNIFORM( ClipSpaceFromLocal );
   UNIFORM( ViewNormalFromLocal );
   UNIFORM( MainTex );
   UNIFORM( ConstantColour );
   UNIFORM( love_ScreenSize );
   ATTRIB( VertexPosition );
   ATTRIB( VertexTexCoord );
   ATTRIB( VertexColour );
#undef ATTRIB
#undef UNIFORM
 
   /* Do other uniforms. */
   glGetProgramiv( shader.program, GL_ACTIVE_UNIFORMS, &shader.nuniforms );
   shader.uniforms = calloc( shader.nuniforms, sizeof( LuaUniform_t ) );
   ntex            = 0;
   for ( GLint i = 0; i < shader.nuniforms; i++ ) {
      LuaUniform_t *u = &shader.uniforms[i];
      glGetActiveUniform( shader.program, (GLuint)i, SHADER_NAME_MAXLEN,
                          &length, &u->size, &u->type, u->name );
      u->id  = glGetUniformLocation( shader.program, u->name );
      u->tex = -1;
 
      /* Textures need special care. */
      if ( ( u->type == GL_SAMPLER_2D ) &&
           ( strcmp( u->name, "MainTex" ) != 0 ) ) {
         if ( shader.tex == NULL )
            shader.tex = array_create( LuaTexture_t );
         LuaTexture_t *t = &array_grow( &shader.tex );
         ntex++;
         t->active  = GL_TEXTURE0 + ntex;
         t->texid   = 0;
         t->uniform = u->id;
         t->value   = ntex;
         u->tex     = ntex - 1;
      }
   }
   qsort( shader.uniforms, shader.nuniforms, sizeof( LuaUniform_t ),
          shader_compareUniform );
 
   if ( gl_checkErr() )
      NLUA_ERROR( L, _( "OpenGL Error!" ) );
 
   lua_pushshader( L, shader );
   return 1;
}

void shader_parseUniformArgsFloat( GLfloat values[4], lua_State *L, int idx,
                                   int n )
{
   if ( lua_istable( L, idx ) ) {
      for ( int j = 0; j < n; j++ ) {
         lua_pushnumber( L, j + 1 );
         lua_gettable( L, idx );
         values[j] = luaL_checknumber( L, -1 );
      }
      lua_pop( L, n );
   } else {
      for ( int j = 0; j < n; j++ )
         values[j] = luaL_checknumber( L, idx + j );
   }
}

void shader_parseUniformArgsInt( GLint values[4], lua_State *L, int idx, int n )
{
   if ( lua_istable( L, idx ) ) {
      for ( int j = 0; j < n; j++ ) {
         lua_pushnumber( L, j + 1 );
         lua_gettable( L, idx );
         values[j] = luaL_checkint( L, -1 );
      }
      lua_pop( L, n );
   } else {
      for ( int j = 0; j < n; j++ )
         values[j] = luaL_checkint( L, idx + j );
   }
}

static int shaderL_send( lua_State *L )
{
   return shaderL_sendHelper( L, 0 );
}

static int shaderL_sendRaw( lua_State *L )
{
   return shaderL_sendHelper( L, 1 );
}

static int shaderL_sendHelper( lua_State *L, int ignore_missing )
{
   const LuaShader_t *ls;
   LuaUniform_t      *u;
   const char        *name;
   int                idx;
   GLfloat            values[4];
   GLint              ivalues[4];
   const glTexture   *tex;
 
   ls   = luaL_checkshader( L, 1 );
   name = luaL_checkstring( L, 2 );
 
   u = shader_getUniform( ls, name );
   if ( u == NULL ) {
      if ( ignore_missing )
         return 0;
      return NLUA_ERROR( L, _( "Shader does not have uniform '%s'!" ), name );
   }
 
   /* With OpenGL 4.1 or ARB_separate_shader_objects, there
    * is no need to set the program first. */
   glUseProgram( ls->program );
   idx = 3;
   switch ( u->type ) {
   case GL_FLOAT:
      shader_parseUniformArgsFloat( values, L, idx, 1 );
      glUniform1f( u->id, values[0] );
      break;
   case GL_FLOAT_VEC2:
      shader_parseUniformArgsFloat( values, L, idx, 2 );
      glUniform2f( u->id, values[0], values[1] );
      break;
   case GL_FLOAT_VEC3:
      shader_parseUniformArgsFloat( values, L, idx, 3 );
      glUniform3f( u->id, values[0], values[1], values[2] );
      break;
   case GL_FLOAT_VEC4:
      shader_parseUniformArgsFloat( values, L, idx, 4 );
      glUniform4f( u->id, values[0], values[1], values[2], values[3] );
      break;
 
   case GL_INT:
      shader_parseUniformArgsInt( ivalues, L, idx, 1 );
      glUniform1i( u->id, ivalues[0] );
      break;
   case GL_INT_VEC2:
      shader_parseUniformArgsInt( ivalues, L, idx, 2 );
      glUniform2i( u->id, ivalues[0], ivalues[1] );
      break;
   case GL_INT_VEC3:
      shader_parseUniformArgsInt( ivalues, L, idx, 3 );
      glUniform3i( u->id, ivalues[0], ivalues[1], ivalues[2] );
      break;
   case GL_INT_VEC4:
      shader_parseUniformArgsInt( ivalues, L, idx, 4 );
      glUniform4i( u->id, ivalues[0], ivalues[1], ivalues[2], ivalues[3] );
      break;
 
   case GL_SAMPLER_2D:
      tex                   = luaL_checktex( L, idx );
      ls->tex[u->tex].texid = tex->texture;
      break;
 
   default:
      NLUA_WARN( L,
                 _( "Unsupported shader uniform type '%d' for uniform '%s'. "
                    "Ignoring." ),
                 u->type, u->name );
   }
   glUseProgram( 0 );
 
   if ( gl_checkErr() )
      NLUA_ERROR( L, _( "OpenGL Error!" ) );
 
   return 0;
}

static int shaderL_hasUniform( lua_State *L )
{
   /* Parameters. */
   const LuaShader_t *ls   = luaL_checkshader( L, 1 );
   const char        *name = luaL_checkstring( L, 2 );
 
   /* Search. */
   lua_pushboolean( L, shader_getUniform( ls, name ) != NULL );
   return 1;
}

static int shaderL_addPostProcess( lua_State *L )
{
   LuaShader_t *ls       = luaL_checkshader( L, 1 );
   const char  *str      = luaL_optstring( L, 2, "final" );
   int          priority = luaL_optinteger( L, 3, 0 );
   int          layer    = PP_LAYER_FINAL;
 
   if ( strcmp( str, "final" ) == 0 )
      layer = PP_LAYER_FINAL;
   else if ( strcmp( str, "game" ) == 0 )
      layer = PP_LAYER_GAME;
   else if ( strcmp( str, "gui" ) == 0 )
      layer = PP_LAYER_GUI;
   else if ( strcmp( str, "core" ) == 0 )
      layer = PP_LAYER_CORE;
   else
      return NLUA_ERROR( L,
                         _( "Layer was '%s', but must be one of 'final', "
                            "'game', 'gui', or 'core'." ),
                         str );
 
   if ( ls->pp_id == 0 )
      ls->pp_id = render_postprocessAdd( ls, layer, priority, 0 );
   lua_pushboolean( L, ls->pp_id > 0 );
   return 1;
}

static int shaderL_rmPostProcess( lua_State *L )
{
   LuaShader_t *ls = luaL_checkshader( L, 1 );
   lua_pushboolean( L, render_postprocessRm( ls->pp_id ) );
   ls->pp_id = 0;
   return 1;
}