/**

 * 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.

#include <malloc.h>  // for alloca().

#endif

#if (defined(__APPLE__) && defined(__MACH__))

#define PLATFORM_MACOSX 1

#endif

#if PLATFORM_MACOSX

#include <Carbon/Carbon.h>

#endif

#define __MOJOSHADER_INTERNAL__ 1

#include "mojoshader_internal.h"

#define GL_GLEXT_LEGACY 1

#include "GL/gl.h"

#include "GL/glext.h"

#ifndef GL_HALF_FLOAT

#define GL_HALF_FLOAT 0x140B

#endif

#ifndef GL_HALF_FLOAT_OES

#define GL_HALF_FLOAT_OES 0x8D61

#endif

struct MOJOSHADER_glShader

{

    const MOJOSHADER_parseData *parseData;

    GLuint handle;

    uint32 refcount;

};

typedef struct

{

    MOJOSHADER_shaderType shader_type;

    const MOJOSHADER_uniform *uniform;

    GLuint location;

    union {

        GLint b;

        GLint i[4];

        GLfloat f[4];

    } value;

    GLfloat *uniform_array_buffer;

} UniformMap;

typedef struct

{

    MOJOSHADER_shaderType shader_type;

    const MOJOSHADER_sampler *sampler;

    GLuint location;

    GLint value;

} SamplerMap;

typedef struct

{

    const MOJOSHADER_attribute *attribute;

    GLuint location;

} AttributeMap;

struct MOJOSHADER_glProgram

{

    MOJOSHADER_glShader *vertex;

    MOJOSHADER_glShader *fragment;

    GLuint handle;

    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);

typedef WINGDIAPI void (APIENTRYP PFNGLENABLEPROC) (GLenum cap);

typedef WINGDIAPI void (APIENTRYP PFNGLDISABLEPROC) (GLenum cap);

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_NV_vertex_program2_option;

    int have_GL_NV_fragment_program2;

    int have_GL_NV_vertex_program3;

    int have_GL_NV_gpu_program4;

    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;

    int have_GL_ARB_half_float_vertex;

    int have_GL_OES_vertex_half_float;

    // Entry points...

    PFNGLGETSTRINGPROC glGetString;

    PFNGLGETERRORPROC glGetError;

    PFNGLGETINTEGERVPROC glGetIntegerv;

    PFNGLENABLEPROC glEnable;

    PFNGLDISABLEPROC glDisable;

    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;

    PFNGLPROGRAMLOCALPARAMETER4FVARBPROC glProgramLocalParameter4fvARB;

    PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC glProgramLocalParameterI4ivNV;

    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 (*profileGetAttribLocation)(MOJOSHADER_glProgram *program, int idx);

    GLint (*profileGetUniformLocation)(MOJOSHADER_glProgram *, MOJOSHADER_glShader *, int);

    GLint (*profileGetSamplerLocation)(MOJOSHADER_glProgram *, MOJOSHADER_glShader *, int);

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

    void (*profileUseProgramObject)(MOJOSHADER_glProgram *program);

    void (*profileUniform4fv)(const MOJOSHADER_parseData *, GLint, GLsizei, GLfloat *);

    void (*profileUniform4iv)(const MOJOSHADER_parseData *, GLint, GLsizei, GLint *);

    void (*profileUniform1i)(const MOJOSHADER_parseData *, GLint, GLint);

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

    int (*profileMustLoadConstantArrays)(void);

};

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

#if PLATFORM_MACOSX

static inline int macosx_version_atleast(int x, int y, int z)

{

    static int checked = 0;

    static int combined = 0;

    if (!checked)

    {

        long ver, major, minor, patch;

        int convert = 0;

        if (Gestalt(gestaltSystemVersion, &ver) != noErr)

            ver = 0x1000;  // oh well.

        else if (ver < 0x1030)

            convert = 1;  // split (ver) into (major),(minor),(patch).

        else

        {

            // presumably this won't fail. But if it does, we'll just use the

            //  original version value. This might cut the value--10.12.11 will

            //  come out to 10.9.9, for example--but it's better than nothing.

            if (Gestalt(gestaltSystemVersionMajor, &major) != noErr)

                convert = 1;

            else if (Gestalt(gestaltSystemVersionMinor, &minor) != noErr)

                convert = 1;

            else if (Gestalt(gestaltSystemVersionBugFix, &patch) != noErr)

                convert = 1;

        } // else

        if (convert)

        {

            major = ((ver & 0xFF00) >> 8);

            major = (((major / 16) * 10) + (major % 16));

            minor = ((ver & 0xF0) >> 4);

            patch = (ver & 0xF);

        } // if

        combined = (major << 16) | (minor << 8) | patch;

        checked = 1;

    } // if

    return (combined >= ((x << 16) | (y << 8) | z));

} // macosx_version_atleast

#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

static inline void toggle_gl_state(GLenum state, int val)

{

    if (val)

        ctx->glEnable(state);

    else

        ctx->glDisable(state);

} // toggle_gl_state

// profile-specific implementations...

#if SUPPORT_PROFILE_GLSL

static inline GLenum glsl_shader_type(const MOJOSHADER_shaderType t)

{

    if (t == MOJOSHADER_TYPE_VERTEX)

        return GL_VERTEX_SHADER;

    else if (t == MOJOSHADER_TYPE_PIXEL)

        return GL_FRAGMENT_SHADER;

    // !!! FIXME: geometry shaders?

    return GL_NONE;

} // glsl_shader_type

static int impl_GLSL_MustLoadConstantArrays(void) { return 1; }

static int impl_GLSL_MaxUniforms(MOJOSHADER_shaderType shader_type)

{

    GLenum pname = GL_NONE;

    GLint val = 0;

    if (shader_type == MOJOSHADER_TYPE_VERTEX)

        pname = GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB;

    else if (shader_type == MOJOSHADER_TYPE_PIXEL)

        pname = GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB;

    else

        return -1;

    ctx->glGetIntegerv(pname, &val);

    return (int) val;

} // impl_GLSL_MaxUniforms

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

{

    GLint ok = 0;

    GLint shaderlen = (GLint) pd->output_len;

    const GLenum shader_type = glsl_shader_type(pd->shader_type);

    GLuint shader = ctx->glCreateShaderObject(shader_type);

    ctx->glShaderSource(shader, 1, (const GLchar **) &pd->output, &shaderlen);

    ctx->glCompileShader(shader);

    ctx->glGetObjectParameteriv(shader, GL_OBJECT_COMPILE_STATUS_ARB, &ok);

    if (!ok)

    {

        GLsizei len = 0;

        ctx->glGetInfoLog(shader, sizeof (error_buffer), &len,

                          (GLchar *) error_buffer);

        *s = 0;

        return 0;

    } // if

    *s = shader;

    return 1;

} // impl_GLSL_CompileShader

static void impl_GLSL_DeleteShader(const GLuint shader)

{

    ctx->glDeleteObject(shader);

} // impl_GLSL_DeleteShader

static void impl_GLSL_DeleteProgram(const GLuint program)

{

    ctx->glDeleteObject(program);

} // impl_GLSL_DeleteProgram

static GLint impl_GLSL_GetUniformLocation(MOJOSHADER_glProgram *program,

                                          MOJOSHADER_glShader *shader, int idx)

{

    return ctx->glGetUniformLocation(program->handle,

                                     shader->parseData->uniforms[idx].name);

} // impl_GLSL_GetUniformLocation

static GLint impl_GLSL_GetSamplerLocation(MOJOSHADER_glProgram *program,

                                          MOJOSHADER_glShader *shader, int idx)

{

    return ctx->glGetUniformLocation(program->handle,

                                     shader->parseData->samplers[idx].name);

} // impl_GLSL_GetSamplerLocation

static GLint impl_GLSL_GetAttribLocation(MOJOSHADER_glProgram *program, int idx)

{

    const MOJOSHADER_parseData *pd = program->vertex->parseData;

    const MOJOSHADER_attribute *a = pd->attributes;

    return ctx->glGetAttribLocation(program->handle, a[idx].name);

} // impl_GLSL_GetAttribLocation

static GLuint impl_GLSL_LinkProgram(MOJOSHADER_glShader *vshader,

                                    MOJOSHADER_glShader *pshader)

{

    const GLuint program = ctx->glCreateProgramObject();

    if (vshader != NULL) ctx->glAttachObject(program, vshader->handle);

    if (pshader != NULL) ctx->glAttachObject(program, pshader->handle);

    ctx->glLinkProgram(program);

    GLint ok = 0;

    ctx->glGetObjectParameteriv(program, GL_OBJECT_LINK_STATUS_ARB, &ok);

    if (!ok)

    {

        GLsizei len = 0;

        ctx->glGetInfoLog(program, sizeof (error_buffer), &len, (GLchar *) error_buffer);

        ctx->glDeleteObject(program);

        return 0;

    } // if

    return program;

} // impl_GLSL_LinkProgram

static void impl_GLSL_UseProgramObject(MOJOSHADER_glProgram *program)

{

    ctx->glUseProgramObject((program != NULL) ? program->handle : 0);

} // impl_GLSL_UseProgramObject

static void impl_GLSL_Uniform4fv(const MOJOSHADER_parseData *pd, GLint loc,

                                 GLsizei siz, GLfloat *v)

{

    ctx->glUniform4fv(loc, siz, v);

} // impl_GLSL_Uniform4fv

static void impl_GLSL_Uniform4iv(const MOJOSHADER_parseData *pd, GLint loc,

                                 GLsizei siz, GLint *v)

{

    ctx->glUniform4iv(loc, siz, v);

} // impl_GLSL_Uniform4iv

static void impl_GLSL_Uniform1i(const MOJOSHADER_parseData *pd, GLint loc,

                                GLint v)

{

    ctx->glUniform1i(loc, v);

} // impl_GLSL_Uniform1i

static void impl_GLSL_SetSampler(GLint loc, GLuint sampler)

{

    ctx->glUniform1i(loc, sampler);

} // impl_GLSL_SetSampler

#endif  // SUPPORT_PROFILE_GLSL

#if SUPPORT_PROFILE_ARB1

static inline GLenum arb1_shader_type(const MOJOSHADER_shaderType t)

{

    if (t == MOJOSHADER_TYPE_VERTEX)

        return GL_VERTEX_PROGRAM_ARB;

    else if (t == MOJOSHADER_TYPE_PIXEL)

        return GL_FRAGMENT_PROGRAM_ARB;

    // !!! FIXME: geometry shaders?

    return GL_NONE;

} // arb1_shader_type

static int impl_ARB1_MustLoadConstantArrays(void) { return 0; }

static int impl_ARB1_MaxUniforms(MOJOSHADER_shaderType shader_type)

{

    GLint retval = 0;

    const GLenum program_type = arb1_shader_type(shader_type);

    if (program_type == GL_NONE)

        return -1;

    ctx->glGetProgramivARB(program_type, GL_MAX_PROGRAM_PARAMETERS_ARB, &retval);

    return (int) retval;  // !!! FIXME: times four?

} // impl_ARB1_MaxUniforms

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

{

    GLint shaderlen = (GLint) pd->output_len;

    const GLenum shader_type = arb1_shader_type(pd->shader_type);

    GLuint shader = 0;

    ctx->glGenProgramsARB(1, &shader);

    ctx->glGetError();  // flush any existing error state.

    ctx->glBindProgramARB(shader_type, shader);

    ctx->glProgramStringARB(shader_type, GL_PROGRAM_FORMAT_ASCII_ARB,

                                shaderlen, pd->output);

    if (ctx->glGetError() == GL_INVALID_OPERATION)

    { 

        GLint pos = 0;

        ctx->glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);

        const GLubyte *errstr = ctx->glGetString(GL_PROGRAM_ERROR_STRING_ARB);

        snprintf(error_buffer, sizeof (error_buffer),

                  "ARB1 compile error at position %d: %s",

                  (int) pos, (const char *) errstr);

        ctx->glBindProgramARB(shader_type, 0);

        ctx->glDeleteProgramsARB(1, &shader);

        *s = 0;

        return 0;

    } // if

    *s = shader;

    return 1;

} // impl_ARB1_CompileShader

static void impl_ARB1_DeleteShader(const GLuint _shader)

{

    GLuint shader = _shader;  // const removal.

    ctx->glDeleteProgramsARB(1, &shader);

} // impl_ARB1_DeleteShader

static void impl_ARB1_DeleteProgram(const GLuint program)

{