/**

 * MojoShader; generate shader programs from bytecode of compiled

 *  Direct3D shaders.

 *

 * Please see the file LICENSE.txt in the source's root directory.

 *

 *  This file written by Ryan C. Gordon.

 */

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <stdarg.h>

#include <assert.h>

#ifdef _MSC_VER

#define WIN32_LEAN_AND_MEAN 1

#include <windows.h>  // GL headers need this for WINGDIAPI definition.

#endif

#include "mojoshader.h"

#define GL_GLEXT_LEGACY 1

#include "GL/gl.h"

#include "GL/glext.h"

// Get basic wankery out of the way here...

typedef unsigned int uint;  // this is a printf() helper. don't use for code.

#ifdef _MSC_VER

#define snprintf _snprintf

typedef unsigned __int8 uint8;

typedef unsigned __int32 uint32;

typedef unsigned __int32 int32;

// Warning Level 4 considered harmful.  :)

#pragma warning(disable: 4100)  // "unreferenced formal parameter"

#pragma warning(disable: 4389)  // "signed/unsigned mismatch"

#else

#include <stdint.h>

typedef uint8_t uint8;

typedef uint32_t uint32;

typedef int32_t int32;

#endif

#define STATICARRAYLEN(x) ( (sizeof ((x))) / (sizeof ((x)[0])) )

#ifndef SUPPORT_PROFILE_GLSL

#define SUPPORT_PROFILE_GLSL 1

#endif

#ifndef SUPPORT_PROFILE_ARB1

#define SUPPORT_PROFILE_ARB1 1

#endif

struct MOJOSHADER_glShader

{

    const MOJOSHADER_parseData *parseData;

    GLuint handle;

    uint32 refcount;

};

typedef struct

{

    MOJOSHADER_shaderType shader_type;

    const MOJOSHADER_uniform *uniform;

    GLuint location;

} UniformMap;

typedef struct

{

    MOJOSHADER_shaderType shader_type;

    const MOJOSHADER_sampler *sampler;

    GLuint location;

} SamplerMap;

typedef struct

{

    const MOJOSHADER_attribute *attribute;

    GLuint location;

} AttributeMap;

struct MOJOSHADER_glProgram

{

    MOJOSHADER_glShader *vertex;

    MOJOSHADER_glShader *fragment;

    GLuint handle;

    uint32 constant_count;  // !!! FIXME: misnamed.

    GLfloat *constants;  // !!! FIXME: misnamed.

    uint32 uniform_count;

    UniformMap *uniforms;

    uint32 sampler_count;

    SamplerMap *samplers;

    uint32 attribute_count;

    AttributeMap *attributes;

    uint32 refcount;

};

#ifndef WINGDIAPI

#define WINGDIAPI

#endif

// Entry points in base OpenGL that lack function pointer prototypes...

typedef WINGDIAPI void (APIENTRYP PFNGLGETINTEGERVPROC) (GLenum pname, GLint *params);

typedef WINGDIAPI const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC) (GLenum name);

typedef WINGDIAPI GLenum (APIENTRYP PFNGLGETERRORPROC) (void);

struct MOJOSHADER_glContext

{

    // Allocators...

    MOJOSHADER_malloc malloc_fn;

    MOJOSHADER_free free_fn;

    void *malloc_data;

    // The constant register files...

    // Man, it kills me how much memory this takes...

    GLfloat vs_reg_file_f[8192 * 4];

    GLint vs_reg_file_i[2047 * 4];

    GLint vs_reg_file_b[2047];

    GLfloat ps_reg_file_f[8192 * 4];

    GLint ps_reg_file_i[2047 * 4];

    GLint ps_reg_file_b[2047];

    GLuint sampler_reg_file[16];

    // GL stuff...

    int opengl_major;

    int opengl_minor;

    MOJOSHADER_glProgram *bound_program;

    char profile[16];

    // Extensions...

    int have_base_opengl;

    int have_GL_ARB_vertex_program;

    int have_GL_ARB_fragment_program;

    int have_GL_ARB_shader_objects;

    int have_GL_ARB_vertex_shader;

    int have_GL_ARB_fragment_shader;

    int have_GL_ARB_shading_language_100;

    int have_GL_NV_half_float;

    // Entry points...

    PFNGLGETSTRINGPROC glGetString;

    PFNGLGETERRORPROC glGetError;

    PFNGLGETINTEGERVPROC glGetIntegerv;

    PFNGLDELETEOBJECTARBPROC glDeleteObject;

    PFNGLATTACHOBJECTARBPROC glAttachObject;

    PFNGLCOMPILESHADERARBPROC glCompileShader;

    PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObject;

    PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObject;

    PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArray;

    PFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArray;

    PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocation;

    PFNGLGETINFOLOGARBPROC glGetInfoLog;

    PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameteriv;

    PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocation;

    PFNGLLINKPROGRAMARBPROC glLinkProgram;

    PFNGLSHADERSOURCEARBPROC glShaderSource;

    PFNGLUNIFORM1IARBPROC glUniform1i;

    PFNGLUNIFORM4FVARBPROC glUniform4fv;

    PFNGLUNIFORM4IVARBPROC glUniform4iv;

    PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObject;

    PFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointer;

    PFNGLGETPROGRAMIVARBPROC glGetProgramivARB;

    PFNGLGETPROGRAMSTRINGARBPROC glGetProgramStringARB;

    PFNGLPROGRAMENVPARAMETER4FVARBPROC glProgramEnvParameter4fvARB;

    PFNGLDELETEPROGRAMSARBPROC glDeleteProgramsARB;

    PFNGLGENPROGRAMSARBPROC glGenProgramsARB;

    PFNGLBINDPROGRAMARBPROC glBindProgramARB;

    PFNGLPROGRAMSTRINGARBPROC glProgramStringARB;

    // interface for profile-specific things.

    int (*profileMaxUniforms)(MOJOSHADER_shaderType shader_type);

    int (*profileCompileShader)(const MOJOSHADER_parseData *pd, GLuint *s);

    void (*profileDeleteShader)(const GLuint shader);

    void (*profileDeleteProgram)(const GLuint program);

    GLint (*profileGetUniformLocation)(GLuint, const MOJOSHADER_parseData *, int);

    GLuint (*profileLinkProgram)(MOJOSHADER_glShader *, MOJOSHADER_glShader *);

    void (*profileUseProgramObject)(MOJOSHADER_glProgram *program);

    void (*profileUniform4fv)(GLint loc, GLsizei siz, GLfloat *v);

    void (*profileUniform4iv)(GLint loc, GLsizei siz, GLint *v);

    void (*profileUniform1i)(GLint loc, GLint v);

    void (*profileSetSampler)(GLint loc, GLuint sampler);

};

// predeclare some profile implementation stuff...

static int impl_GLSL_MaxUniforms(MOJOSHADER_shaderType shader_type);

static int impl_GLSL_CompileShader(const MOJOSHADER_parseData *pd, GLuint *s);

static void impl_GLSL_DeleteShader(const GLuint shader);

static void impl_GLSL_DeleteProgram(const GLuint program);

static GLint impl_GLSL_GetUniformLocation(GLuint, const MOJOSHADER_parseData *, int);

static GLuint impl_GLSL_LinkProgram(MOJOSHADER_glShader *, MOJOSHADER_glShader *);

static void impl_GLSL_UseProgramObject(MOJOSHADER_glProgram *program);

static void impl_GLSL_Uniform4fv(GLint loc, GLsizei siz, GLfloat *v);

static void impl_GLSL_Uniform4iv(GLint loc, GLsizei siz, GLint *v);

static void impl_GLSL_Uniform1i(GLint loc, GLint v);

static void impl_GLSL_SetSampler(GLint loc, GLuint sampler);

static int impl_ARB1_MaxUniforms(MOJOSHADER_shaderType shader_type);

static int impl_ARB1_CompileShader(const MOJOSHADER_parseData *pd, GLuint *s);

static void impl_ARB1_DeleteShader(const GLuint shader);

static void impl_ARB1_DeleteProgram(const GLuint program);

static GLint impl_ARB1_GetUniformLocation(GLuint, const MOJOSHADER_parseData *, int);

static GLuint impl_ARB1_LinkProgram(MOJOSHADER_glShader *, MOJOSHADER_glShader *);

static void impl_ARB1_UseProgramObject(MOJOSHADER_glProgram *program);

static void impl_ARB1_Uniform4fv(GLint loc, GLsizei siz, GLfloat *v);

static void impl_ARB1_Uniform4iv(GLint loc, GLsizei siz, GLint *v);

static void impl_ARB1_Uniform1i(GLint loc, GLint v);

static void impl_ARB1_SetSampler(GLint loc, GLuint sampler);

static MOJOSHADER_glContext *ctx = NULL;

// Error state...

static char error_buffer[1024] = { '\0' };

static void set_error(const char *str)

{

    snprintf(error_buffer, sizeof (error_buffer), "%s", str);

} // set_error

// #define this to force app to supply an allocator, so there's no reference

//  to the C runtime's malloc() and free()...

#if MOJOSHADER_FORCE_ALLOCATOR

#define internal_malloc NULL

#define internal_free NULL

#else

static void *internal_malloc(int bytes, void *d) { return malloc(bytes); }

static void internal_free(void *ptr, void *d) { free(ptr); }

#endif

static inline void *Malloc(const size_t len)

{

    void *retval = ctx->malloc_fn((int) len, ctx->malloc_data);

    if (retval == NULL)

        set_error("out of memory");

    return retval;

} // Malloc

static inline void Free(void *ptr)

{

    if (ptr != NULL)

        ctx->free_fn(ptr, ctx->malloc_data);

} // Free

const char *MOJOSHADER_glGetError(void)

{

    return error_buffer;

} // MOJOSHADER_glGetError

static void *loadsym(void *(*lookup)(const char *fn), const char *fn, int *ext)

{

    void *retval = NULL;

    if (lookup != NULL)

    {

        retval = lookup(fn);

        if (retval == NULL)

        {

            char arbfn[64];

            snprintf(arbfn, sizeof (arbfn), "%sARB", fn);

            retval = lookup(arbfn);

        } // if

    } // if

    if (retval == NULL)

        *ext = 0;

    return retval;

} // loadsym

static void lookup_entry_points(void *(*lookup)(const char *fnname))

{

    #define DO_LOOKUP(ext, typ, fn) ctx->fn = (typ) loadsym(lookup, #fn, &ctx->have_##ext)

    DO_LOOKUP(base_opengl, PFNGLGETSTRINGPROC, glGetString);

    DO_LOOKUP(base_opengl, PFNGLGETERRORPROC, glGetError);

    DO_LOOKUP(base_opengl, PFNGLGETINTEGERVPROC, glGetIntegerv);

    DO_LOOKUP(GL_ARB_shader_objects, PFNGLDELETEOBJECTARBPROC, glDeleteObject);

    DO_LOOKUP(GL_ARB_shader_objects, PFNGLATTACHOBJECTARBPROC, glAttachObject);

    DO_LOOKUP(GL_ARB_shader_objects, PFNGLCOMPILESHADERARBPROC, glCompileShader);

    DO_LOOKUP(GL_ARB_shader_objects, PFNGLCREATEPROGRAMOBJECTARBPROC, glCreateProgramObject);

    DO_LOOKUP(GL_ARB_shader_objects, PFNGLCREATESHADEROBJECTARBPROC, glCreateShaderObject);

    DO_LOOKUP(GL_ARB_shader_objects, PFNGLGETINFOLOGARBPROC, glGetInfoLog);

    DO_LOOKUP(GL_ARB_shader_objects, PFNGLGETOBJECTPARAMETERIVARBPROC, glGetObjectParameteriv);

    DO_LOOKUP(GL_ARB_shader_objects, PFNGLGETUNIFORMLOCATIONARBPROC, glGetUniformLocation);

    DO_LOOKUP(GL_ARB_shader_objects, PFNGLLINKPROGRAMARBPROC, glLinkProgram);

    DO_LOOKUP(GL_ARB_shader_objects, PFNGLSHADERSOURCEARBPROC, glShaderSource);

    DO_LOOKUP(GL_ARB_shader_objects, PFNGLUNIFORM1IARBPROC, glUniform1i);

    DO_LOOKUP(GL_ARB_shader_objects, PFNGLUNIFORM4FVARBPROC, glUniform4fv);

    DO_LOOKUP(GL_ARB_shader_objects, PFNGLUNIFORM4IVARBPROC, glUniform4iv);

    DO_LOOKUP(GL_ARB_shader_objects, PFNGLUSEPROGRAMOBJECTARBPROC, glUseProgramObject);

    DO_LOOKUP(GL_ARB_vertex_shader, PFNGLDISABLEVERTEXATTRIBARRAYARBPROC, glDisableVertexAttribArray);

    DO_LOOKUP(GL_ARB_vertex_shader, PFNGLENABLEVERTEXATTRIBARRAYARBPROC, glEnableVertexAttribArray);

    DO_LOOKUP(GL_ARB_vertex_shader, PFNGLGETATTRIBLOCATIONARBPROC, glGetAttribLocation);

    DO_LOOKUP(GL_ARB_vertex_shader, PFNGLVERTEXATTRIBPOINTERARBPROC, glVertexAttribPointer);

    DO_LOOKUP(GL_ARB_vertex_program, PFNGLUSEPROGRAMOBJECTARBPROC, glUseProgramObject);

    DO_LOOKUP(GL_ARB_vertex_program, PFNGLVERTEXATTRIBPOINTERARBPROC, glVertexAttribPointer);

    DO_LOOKUP(GL_ARB_vertex_program, PFNGLGETPROGRAMIVARBPROC, glGetProgramivARB);

    DO_LOOKUP(GL_ARB_vertex_program, PFNGLGETPROGRAMSTRINGARBPROC, glGetProgramStringARB);

    DO_LOOKUP(GL_ARB_vertex_program, PFNGLPROGRAMENVPARAMETER4FVARBPROC, glProgramEnvParameter4fvARB);

    DO_LOOKUP(GL_ARB_vertex_program, PFNGLDELETEPROGRAMSARBPROC, glDeleteProgramsARB);

    DO_LOOKUP(GL_ARB_vertex_program, PFNGLGENPROGRAMSARBPROC, glGenProgramsARB);

    DO_LOOKUP(GL_ARB_vertex_program, PFNGLBINDPROGRAMARBPROC, glBindProgramARB);

    DO_LOOKUP(GL_ARB_vertex_program, PFNGLPROGRAMSTRINGARBPROC, glProgramStringARB);

    #undef DO_LOOKUP

} // lookup_entry_points

static int verify_extension(const char *ext, int have, const char *extlist,

                            int major, int minor)

{

    if (have == 0)

        return 0;  // don't bother checking, we're missing an entry point.

    else if (!ctx->have_base_opengl)

        return 0;  // don't bother checking, we're missing basic functionality.

    // See if it's in the spec for this GL implementation's version.

    if (major >= 0)

    {

        if ( ((ctx->opengl_major << 16) | (ctx->opengl_minor & 0xFFFF)) >=

             ((major << 16) | (minor & 0xFFFF)) )

            return 1;

    } // if

    // Not available in the GL version, check the extension list.

    const char *ptr = strstr(extlist, ext);

    if (ptr == NULL)

        return 0;

    const char endchar = ptr[strlen(ext)];

    if ((endchar == '\0') || (endchar == ' '))

        return 1;  // extension is in the list.

    return 0;  // just not supported, fail.

} // verify_extension

static void parse_opengl_version(const char *verstr)

{

    if (verstr == NULL)

        ctx->opengl_major = ctx->opengl_minor = 0;

    else

        sscanf(verstr, "%d.%d", &ctx->opengl_major, &ctx->opengl_minor);

} // parse_opengl_version

static void load_extensions(void *(*lookup)(const char *fnname))

{

    const char *extlist = NULL;

    ctx->have_base_opengl = 1;

    ctx->have_GL_ARB_vertex_program = 1;

    ctx->have_GL_ARB_fragment_program = 1;

    ctx->have_GL_ARB_shader_objects = 1;

    ctx->have_GL_ARB_vertex_shader = 1;

    ctx->have_GL_ARB_fragment_shader = 1;

    ctx->have_GL_ARB_shading_language_100 = 1;

    ctx->have_GL_NV_half_float = 1;

    lookup_entry_points(lookup);

    if (!ctx->have_base_opengl)

        set_error("missing basic OpenGL entry points");

    else

    {

        parse_opengl_version((const char *) ctx->glGetString(GL_VERSION));

        extlist = (const char *) ctx->glGetString(GL_EXTENSIONS);

    } // else

    if (extlist == NULL)

        extlist = "";  // just in case.

    #define VERIFY_EXT(ext, major, minor) \

        ctx->have_##ext = verify_extension(#ext, ctx->have_##ext, extlist, major, minor)

    VERIFY_EXT(GL_ARB_vertex_program, -1, -1);

    VERIFY_EXT(GL_ARB_fragment_program, -1, -1);

    VERIFY_EXT(GL_ARB_shader_objects, 2, 0);

    VERIFY_EXT(GL_ARB_vertex_shader, 2, 0);

    VERIFY_EXT(GL_ARB_fragment_shader, 2, 0);

    VERIFY_EXT(GL_ARB_shading_language_100, 2, 0);

    VERIFY_EXT(GL_NV_half_float, -1, -1);

    #undef VERIFY_EXT

} // load_extensions

static int valid_profile(const char *profile)

{

    if (!ctx->have_base_opengl)

        return 0;

    #define MUST_HAVE(p, x) \

        if (!ctx->have_##x) { set_error(#p " profile needs " #x); return 0; }

    if (profile == NULL)

    {

        set_error("NULL profile");

        return 0;

    } // if

    #if SUPPORT_PROFILE_ARB1

    else if (strcmp(profile, MOJOSHADER_PROFILE_ARB1) == 0)

    {

        MUST_HAVE(MOJOSHADER_PROFILE_ARB1, GL_ARB_vertex_program);

        MUST_HAVE(MOJOSHADER_PROFILE_ARB1, GL_ARB_fragment_program);

    } // else if

    #endif

    #if SUPPORT_PROFILE_GLSL

    else if (strcmp(profile, MOJOSHADER_PROFILE_GLSL) == 0)

    {

        MUST_HAVE(MOJOSHADER_PROFILE_GLSL, GL_ARB_shader_objects);

        MUST_HAVE(MOJOSHADER_PROFILE_GLSL, GL_ARB_vertex_shader);

        MUST_HAVE(MOJOSHADER_PROFILE_GLSL, GL_ARB_fragment_shader);

        MUST_HAVE(MOJOSHADER_PROFILE_GLSL, GL_ARB_shading_language_100);

    } // else if

    #endif

    else

    {

        set_error("unknown or unsupported profile");

        return 0;

    } // else

    #undef MUST_HAVE

    return 1;

} // valid_profile

const char *MOJOSHADER_glBestProfile(void *(*lookup)(const char *fnname))

{

    const char *retval = NULL;

    MOJOSHADER_glContext _ctx;

    MOJOSHADER_glContext *current_ctx = ctx;

    ctx = &_ctx;

    memset(ctx, '\0', sizeof (MOJOSHADER_glContext));

    load_extensions(lookup);

    if (ctx->have_base_opengl)

    {

        static const char *priority[] = {

            MOJOSHADER_PROFILE_GLSL,

            MOJOSHADER_PROFILE_ARB1,

        };

        int i;

        for (i = 0; i < STATICARRAYLEN(priority); i++)

        {

            // !!! FIXME: if Mac OS X <= 10.4, don't ever pick GLSL, even if

            // !!! FIXME:  the system claims it is available.

            if (valid_profile(priority[i]))

            {

                retval = priority[i];

                break;

            } // if

        } // for

        if (retval == NULL)

            set_error("no profiles available");

    } // if

    ctx = current_ctx;

    return retval;

} // MOJOSHADER_glBestProfile

MOJOSHADER_glContext *MOJOSHADER_glCreateContext(const char *profile,

                                        void *(*lookup)(const char *fnname),

                                        MOJOSHADER_malloc m, MOJOSHADER_free f,

                                        void *d)

{

    MOJOSHADER_glContext *retval = NULL;

    MOJOSHADER_glContext *current_ctx = ctx;

    ctx = NULL;

    if (m == NULL) m = internal_malloc;

    if (f == NULL) f = internal_free;

    ctx = (MOJOSHADER_glContext *) m(sizeof (MOJOSHADER_glContext), d);

    if (ctx == NULL)

    {

        set_error("out of memory");