libShaderFile/header/libShaderFile.h

#ifndef LIB_SHADER_FILE_H
#define LIB_SHADER_FILE_H

#include <stdint.h>
#include <stdbool.h>

/**********************************************************************************************************************************/
/* public interface                                                                                                               */
/**********************************************************************************************************************************/
#define LSF_LOGLEVEL_DEBUG                      0
#define LSF_LOGLEVEL_INFO                       1
#define LSF_LOGLEVEL_WARNING                    2
#define LSF_LOGLEVEL_ERROR                      3
       
#define LSF_ERR_NONE                            0x00000000
#define LSF_ERR_NOT_INIT                        0x00000001
#define LSF_ERR_INVALID_HANDLE_SHADER_FILE      0x00000010
#define LSF_ERR_INVALID_HANDLE_SHADER_GENERATOR 0x00000011
#define LSF_ERR_INVALID_HANDLE_STREAM           0x00000012
#define LSF_ERR_INVALID_GENERATOR_NAME          0x00000020
#define LSF_ERR_INVALID_PROPERTY_INDEX          0x00000021
#define LSF_ERR_INVALID_PROPERTY_NAME           0x00000022
#define LSF_ERR_GENERATOR_NOT_ASSIGNED_TO_FILE  0x00000023
#define LSF_ERR_UNKNOWN_IDENTFIFIER             0x00001000
#define LSF_ERR_DUPLICATE_IDENTIFIER            0x00001001
#define LSF_ERR_OUT_OF_RANGE                    0x00001002
#define LSF_ERR_INVALID_IDENTIFIER              0x00001003
#define LSF_ERR_INVALID_PARAMTER_COUNT          0x00001004
#define LSF_ERR_INVALID_PARAMTER                0x00001005
#define LSF_ERR_UNEXPECTED_TOKEN                0x00001006
#define LSF_ERR_INVALID_TOKEN                   0x00001007
#define LSF_ERR_EXPRESSION_INTERNAL             0x00001008
#define LSF_ERR_EXPRESSION                      0x00001009
#define LSF_ERR_SHADER_PART_INTERNAL            0x0000100A
#define LSF_ERR_SHADER_PART                     0x0000100B
#define LSF_ERR_INVALID_LIBRARY_NAME            0x00002000
#define LSF_ERR_INVALID_LIBRARY_HANDLE          0x00002001
#define LSF_ERR_INVALID_METHOD_NAME             0x00002002
#define LSF_ERR_UNKNOWN                         0xFFFFFFFF

#define LSF_SEEK_BEG                            0
#define LSF_SEEK_CUR                            1
#define LSF_SEEK_END                            2

#if __MINGW32__
#  define WINAPI __stdcall
#else
#  define WINAPI
#endif

typedef uint32_t    lsf_error_code_t;
typedef uint32_t    lsf_log_level_t;
typedef uint32_t    lsf_seek_origin_t;

typedef void*       lsf_shader_file_handle_t;
typedef void*       lsf_shader_generator_handle_t;
typedef void*       lsf_stream_handle_t;

/** function pointer to write log messages
 * @param loglevel      log level of current message (see LSF_LOGLEVEL_*)
 * @param msg           message to log
 * @param userargs      user defined arguments */
typedef void (WINAPI *lsf_shader_file_log_callback_t)(const lsf_log_level_t loglevel, const char* msg, const void* userargs);

/** function pointer to save shader code
 * @param filename      filename to save shader code to
 * @param handle        handle to stream data (use lsf_stream_* methods to read/write data)
 * @param userargs      user defined arguments */ 
typedef void (WINAPI *lsf_save_data_callback_t)(const char* filename, const lsf_stream_handle_t handle, const void* userargs);

/** function pointer to load shader code
 * @param filename      filename to load shader code from
 * @param handle        handle to stream data (use lsf_stream_* methods to read/write data)
 * @param userargs      user defined arguments */
typedef bool (WINAPI *lsf_load_data_callback_t)(const char* filename, const lsf_stream_handle_t handle, const void* userargs);


/** create a new shader file handle
 * @returns         shader file handle or NULL (check lsf_get_last_error_* for more details) */
lsf_shader_file_handle_t (WINAPI *lsf_shader_file_create) ();

/** set the callback for log messages of a specific shader file handle
 * @param handle    shader file handle to set callback for
 * @param callback  pointer to callback function
 * @param userargs  user defined arguments
 * @returns         error code (see LSF_ERR_*) */
lsf_error_code_t (WINAPI *lsf_shader_file_set_log_callback) (const lsf_shader_file_handle_t handle, const lsf_shader_file_log_callback_t callback, const void* userargs);

/** load shader file code from a given file
 * @param handle    handle of shader file to load from file
 * @param filename  file to load shader code from
 * @returns         error code (see LSF_ERR_*) */
lsf_error_code_t (WINAPI *lsf_shader_file_load_from_file) (const lsf_shader_file_handle_t handle, const char* filename);

/** load shader code from function
 * @param handle    handle of shader file to load
 * @param filename  name of the file to load code from (will be passed to callback; can be used as key to identify data to load)
 * @param callback  function to call to request data
 * @param userargs  user defined arguments (will be passed to callback)
 * @returns         error code (see LSF_ERR_) */
lsf_error_code_t (WINAPI *lsf_shader_file_load_from_func) (const lsf_shader_file_handle_t handle, const char* filename, const lsf_load_data_callback_t callback, const void* userargs);

/** save shader file code to a given file
 * @param handle    handle of shader file to save to file
 * @param filename  file to save shader code to
 * @returns         error code (see LSF_ERR_*) */
lsf_error_code_t (WINAPI *lsf_shader_file_save_to_file) (const lsf_shader_file_handle_t handle, const char* filename);

/** save shader code to function
 * @param handle    handle of shader file to load
 * @param filename  name of the file to save code to (will be passed to callback; can be used as key to identify data to save)
 * @param callback  function to call to save data
 * @param userargs  user defined arguments (will be passed to callback)
 * @returns         error code (see LSF_ERR_) */
lsf_error_code_t (WINAPI *lsf_shader_file_save_to_func) (const lsf_shader_file_handle_t handle, const char* filename, const lsf_load_data_callback_t callback, const void* userargs);

/** generate a list of all code generators in a shader file
 * @param handle    shader file handle to generate list for
 * @returns         list of code generators (seperated by linebreak) or NULL (check lsf_get_last_error_* for more details) */
const char* (WINAPI *lsf_shader_file_get_generator_names) (const lsf_shader_file_handle_t handle);

/** destroy a shader file handle
 * @param handle    shader file handle to destroy 
 * @returns         error code (see LSF_ERR_*) */
lsf_error_code_t (WINAPI *lsf_shader_file_destroy) (const lsf_shader_file_handle_t handle);


/** create a new code generator from a given shader file. the generator is owned by the shader file handle.
 *  if you destroy a shader file handle, all associated generator handles will be destroyed to.
 * @param handle    shader file handle to create generator from
 * @param name      name of the generator (see lsf_shader_file_get_generator_names to get a list of all valid names)
 * @return          generator handle of NULL (check lsf_get_last_error_* for more details) */
lsf_shader_generator_handle_t (WINAPI *lsf_generator_create) (const lsf_shader_file_handle_t handle, const char* name);

/** generate a list of all known properties within a given generator handle
 * @handle          generator handle to get properties from
 * @return          list of all known properties (seperated by linebreak) or NULL (check lsf_get_last_error_* for more details) */
const char* (WINAPI *lsf_generator_get_property_names) (const lsf_shader_generator_handle_t handle);

/** get a property value by its index
 * @param handle    generator handle
 * @param index     index of the property (see lsf_generator_get_property_names to calculate property index)
 * @return          property value or NULL (check lsf_get_last_error_* for more details) */
const char* (WINAPI *lsf_generator_get_property) (const lsf_shader_generator_handle_t handle, const int index);

/** get a property value by its name
 * @param handle    generator handle
 * @param name      name of the property
 * @return          property value or NULL (check lsf_get_last_error_* for more details) */
const char* (WINAPI *lsf_generator_get_property_by_name) (const lsf_shader_generator_handle_t handle, const char* name);

/** set a property value by its index
 * @param handle    generator handle
 * @param index     index of the property (see lsf_generator_get_property_names to calculate property index)
 * @param value     new value of the property
 * @return          error code (see LSF_ERR_*) */
lsf_error_code_t (WINAPI *lsf_generator_set_property) (const lsf_shader_generator_handle_t handle, const int index, const char* value);

/** set a property value by its name
 * @param handle    generator handle
 * @param name      name of the property
 * @param value     new value of the property
 * @return          error code (see LSF_ERR_*) */
lsf_error_code_t (WINAPI *lsf_generator_set_property_by_name) (const lsf_shader_generator_handle_t handle, const char* name, const char* value);

/** generate shader code
 * @param handle    generator handle
 * @return          generated shader code or NULL (check lsf_get_last_error_* for more details) */
const char* (WINAPI *lsf_generator_generate_code) (const lsf_shader_generator_handle_t handle);

/** destroy a generator handle
 * @param handle    generator handle to destroy 
 * @returns         error code (see LSF_ERR_*) */
lsf_error_code_t (WINAPI *lsf_generator_destroy) (const lsf_shader_generator_handle_t handle);


/** get size of stream
 * @param handle    stream handle to get size from
 * @returns         stream size on success, -1 otherwise (check lsf_get_last_error_* for more details) */
int (WINAPI *lsf_stream_get_size) (const lsf_stream_handle_t handle);

/** set size of stream
 * @param handle    stream handle to set size from
 * @returns         error code (see LSF_ERR_*) */
lsf_error_code_t (WINAPI *lsf_stream_set_size) (const lsf_stream_handle_t handle, const int size);

/** seek stream
 * @param handle    stream handle to seek
 * @param offset    number of bytes to use as offset
 * @param origin    seek origin
 * @returns         new position on success, -1 otherwise (check lsf_get_last_error_* for more details) */
int (WINAPI *lsf_stream_seek) (const lsf_stream_handle_t handle, const int offset, const lsf_seek_origin_t origin);

/** read data from stream
 * @param handle    stream handle to read data from
 * @param buffer    buffer to copy data into
 * @param size      number of bytes to read
 * @returns         number of read bytes on success, -1 otherwise (check lsf_get_last_error_* for more details) */
int (WINAPI *lsf_stream_read) (const lsf_stream_handle_t handle, const void *buffer, const int size);

/** write data to stream
 * @param handle    stream handle to write data to
 * @param buffer    buffer to copy data from
 * @param size      number of bytes to write
 * @returns         number of written bytes on success, -1 otherwise (check lsf_get_last_error_* for more details) */
int (WINAPI *lsf_stream_write) (const lsf_stream_handle_t handle, const void *buffer, const int size);


/** get last error code 
 * @return          error code of last failed operation */
lsf_error_code_t (WINAPI *lsf_get_last_error_code) ();

/** get last error message
 * @return          error message of last failed operation */
const char* (WINAPI *lsf_get_last_error_msg) ();

/** get last error trace
 * @return          error message and a trace of last failed operation */
const char* (WINAPI *lsf_get_last_error_trace) ();

/** initialize the library
 * @param libname   name of the shared library to load data from
 * @return          0 on success, LSF_ERR_* otherwise */
int lsf_init(const char* libname);

/** finalize the library
 * @return          0 on success, LSF_ERR_* otherwise */
int lsf_finish(void);


/**********************************************************************************************************************************/
/* internal initialization code                                                                                                   */
/**********************************************************************************************************************************/
//#define LSF_DEBUG
#ifdef LSF_DEBUG
#  include <stdio.h>
#endif

#if WIN32 || WIN64 || _WIN32 || _WIN64
#  include <windows.h>

typedef HMODULE lib_handle_t;

lib_handle_t open_lib(const char* name)
    { return LoadLibrary(name); };
    
void* get_addr(lib_handle_t handle, const char* name)
    { return GetProcAddress(handle, name); };

int close_lib(lib_handle_t handle)
    { return FreeLibrary(handle); };
    
#elif LINUX || __linux__
#  include <dlfcn.h>

typedef void* lib_handle_t;

lib_handle_t open_lib(const char* name)
    { return dlopen(name, RTLD_LAZY); };
    
void* get_addr(lib_handle_t handle, const char* name)
    { return dlsym(handle, name); };

int close_lib(lib_handle_t handle)
    { return !dlclose(handle); };

#else
#   error "unknown operation system"
#endif

#ifndef LSF_DEBUG
#  define LoadProc(proc, name) \
        proc = get_addr(handle, name); \
        if (!proc) \
            return LSF_ERR_INVALID_METHOD_NAME
#else
#  define LoadProc(proc, name) \
        proc = get_addr(handle, name); \
        printf("load method '%s' (addr=0x%016x)\n", name, proc); \
        if (!proc) \
            return LSF_ERR_INVALID_METHOD_NAME
#endif

lsf_error_code_t (WINAPI *lsf_init_intern)();
lsf_error_code_t (WINAPI *lsf_finish_intern)();

lib_handle_t handle = NULL;

int lsf_init(const char* libname)
{
#ifdef LSF_DEBUG
    printf("loading library '%s'\n", libname);
#endif
    
    handle = open_lib(libname);
    if (!handle)
        return LSF_ERR_INVALID_LIBRARY_NAME;
    
#ifdef LSF_DEBUG
    printf("    done (handle=0x%016x)\n", handle);
#endif
    
    LoadProc(lsf_shader_file_create,                "lsf_ShaderFile_create");
    LoadProc(lsf_shader_file_set_log_callback,      "lsf_ShaderFile_setLogCallback");
    LoadProc(lsf_shader_file_load_from_file,        "lsf_ShaderFile_loadFromFile");
    LoadProc(lsf_shader_file_save_to_file,          "lsf_ShaderFile_saveToFile");
    LoadProc(lsf_shader_file_get_generator_names,   "lsf_ShaderFile_getGeneratorNames");
    LoadProc(lsf_shader_file_destroy,               "lsf_ShaderFile_destroy");

    LoadProc(lsf_generator_create,                  "lsf_Generator_create");
    LoadProc(lsf_generator_get_property_names,      "lsf_Generator_getPropertyNames");
    LoadProc(lsf_generator_get_property,            "lsf_Generator_getProperty");
    LoadProc(lsf_generator_get_property_by_name,    "lsf_Generator_getPropertyByName");
    LoadProc(lsf_generator_set_property,            "lsf_Generator_setProperty");
    LoadProc(lsf_generator_set_property_by_name,    "lsf_Generator_setPropertyByName");
    LoadProc(lsf_generator_generate_code,           "lsf_Generator_generateCode");
    LoadProc(lsf_generator_destroy,                 "lsf_Generator_destroy");
    
    LoadProc(lsf_stream_get_size,                   "lsf_Stream_getSize");
    LoadProc(lsf_stream_set_size,                   "lsf_Stream_setSize");
    LoadProc(lsf_stream_seek,                       "lsf_Stream_seek");
    LoadProc(lsf_stream_read,                       "lsf_Stream_read");
    LoadProc(lsf_stream_write,                      "lsf_Stream_write");
    
    LoadProc(lsf_init_intern,                       "lsf_init");
    LoadProc(lsf_get_last_error_code,               "lsf_getLastErrorCode");
    LoadProc(lsf_get_last_error_msg,                "lsf_getLastErrorMsg");
    LoadProc(lsf_get_last_error_trace,              "lsf_getLastErrorTrace");
    LoadProc(lsf_finish_intern,                     "lsf_finish");
    
    return lsf_init_intern();
}

int lsf_finish(void)
{
    lsf_error_code_t err = lsf_finish_intern();
    if (!close_lib(handle))
        return LSF_ERR_INVALID_LIBRARY_HANDLE;
    return err;
}

#endif /* LIB_SHADER_FILE_H */