/**

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

// !!! FIXME: most of these _MSC_VER should probably be _WINDOWS?

#ifdef _MSC_VER

#define WIN32_LEAN_AND_MEAN 1

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

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

    GLint location;

} UniformMap;

typedef struct

{

    const MOJOSHADER_attribute *attribute;

    GLint location;

} AttributeMap;

struct MOJOSHADER_glProgram

{

    MOJOSHADER_glShader *vertex;

    MOJOSHADER_glShader *fragment;

    GLuint handle;

    uint32 generation;

    uint32 uniform_count;

    UniformMap *uniforms;

    uint32 attribute_count;

    AttributeMap *attributes;

    size_t vs_uniforms_float4_count;

    GLfloat *vs_uniforms_float4;

    size_t vs_uniforms_int4_count;

    GLint *vs_uniforms_int4;

    size_t vs_uniforms_bool_count;

    GLint *vs_uniforms_bool;

    size_t ps_uniforms_float4_count;

    GLfloat *ps_uniforms_float4;

    size_t ps_uniforms_int4_count;

    GLint *ps_uniforms_int4;

    size_t ps_uniforms_bool_count;

    GLint *ps_uniforms_bool;

    uint32 refcount;

    // GLSL uses these...location of uniform arrays.

    GLint vs_float4_loc;

    GLint vs_int4_loc;

    GLint vs_bool_loc;

    GLint ps_float4_loc;

    GLint ps_int4_loc;

    GLint ps_bool_loc;

};

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

// Max entries for each register file type...

#define MAX_REG_FILE_F 8192

#define MAX_REG_FILE_I 2047

#define MAX_REG_FILE_B 2047

struct MOJOSHADER_glContext

{

    // Allocators...

    MOJOSHADER_malloc malloc_fn;

    MOJOSHADER_free free_fn;

    void *malloc_data;

    // The constant register files...

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

    // !!! FIXME:  ... make this dynamically allocated on demand.

    GLfloat vs_reg_file_f[MAX_REG_FILE_F * 4];

    GLint vs_reg_file_i[MAX_REG_FILE_I * 4];

    uint8 vs_reg_file_b[MAX_REG_FILE_B];

    GLfloat ps_reg_file_f[MAX_REG_FILE_F * 4];

    GLint ps_reg_file_i[MAX_REG_FILE_I * 4];

    uint8 ps_reg_file_b[MAX_REG_FILE_B];

    GLuint sampler_reg_file[16];

    // This increments every time we change the register files.

    uint32 generation;

    // This tells us which vertex attribute arrays we have enabled.

    GLint max_attrs;

    uint8 want_attr[32];

    uint8 have_attr[32];

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

    PFNGLUNIFORM1IVARBPROC glUniform1iv;

    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 *program, MOJOSHADER_glShader *shader, int idx);

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

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

    void (*profileFinalInitProgram)(MOJOSHADER_glProgram *program);

    void (*profileUseProgramObject)(MOJOSHADER_glProgram *program);

    void (*profilePushConstantArray)(MOJOSHADER_glProgram *, const MOJOSHADER_uniform *, const GLfloat *);

    void (*profilePushUniforms)(void);

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

    int (*profileMustPushConstantArrays)(void);

    int (*profileMustPushSamplers)(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)

    {

        SInt32 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_MustPushConstantArrays(void) { return 1; }

static int impl_GLSL_MustPushSamplers(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 0;  // no-op, we push this as one big-ass array now.

} // 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_FinalInitProgram(MOJOSHADER_glProgram *program)

{

    program->vs_float4_loc =

        ctx->glGetUniformLocation(program->handle, "vs_uniforms_vec4");

    program->vs_int4_loc =

        ctx->glGetUniformLocation(program->handle, "vs_uniforms_ivec4");

    program->vs_bool_loc =

        ctx->glGetUniformLocation(program->handle, "vs_uniforms_bool");

    program->ps_float4_loc =

        ctx->glGetUniformLocation(program->handle, "ps_uniforms_vec4");

    program->ps_int4_loc =

        ctx->glGetUniformLocation(program->handle, "ps_uniforms_ivec4");

    program->ps_bool_loc =

        ctx->glGetUniformLocation(program->handle, "ps_uniforms_bool");

} // impl_GLSL_FinalInitProgram

static void impl_GLSL_UseProgramObject(MOJOSHADER_glProgram *program)

{

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

} // impl_GLSL_UseProgramObject

static void impl_GLSL_PushConstantArray(MOJOSHADER_glProgram *program,

                                        const MOJOSHADER_uniform *u,

                                        const GLfloat *f)

{

    const GLint loc = ctx->glGetUniformLocation(program->handle, u->name);

    if (loc >= 0)   // not optimized out?

        ctx->glUniform4fv(loc, u->array_count, f);

} // impl_GLSL_PushConstantArray

static void impl_GLSL_PushUniforms(void)

{

    const MOJOSHADER_glProgram *program = ctx->bound_program;

    assert(program->uniform_count > 0);  // don't call with nothing to do!

    if (program->vs_float4_loc != -1)

    {

        ctx->glUniform4fv(program->vs_float4_loc,

                          program->vs_uniforms_float4_count,

                          program->vs_uniforms_float4);

    } // if

    if (program->vs_int4_loc != -1)

    {

        ctx->glUniform4iv(program->vs_int4_loc,

                          program->vs_uniforms_int4_count,

                          program->vs_uniforms_int4);

    } // if

    if (program->vs_bool_loc != -1)

    {

        ctx->glUniform1iv(program->vs_bool_loc,

                          program->vs_uniforms_bool_count,

                          program->vs_uniforms_bool);

    } // if

    if (program->ps_float4_loc != -1)

    {

        ctx->glUniform4fv(program->ps_float4_loc,

                          program->ps_uniforms_float4_count,

                          program->ps_uniforms_float4);

    } // if

    if (program->ps_int4_loc != -1)

    {

        ctx->glUniform4iv(program->ps_int4_loc,

                          program->ps_uniforms_int4_count,

                          program->ps_uniforms_int4);

    } // if

    if (program->ps_bool_loc != -1)

    {

        ctx->glUniform1iv(program->ps_bool_loc,

                          program->ps_uniforms_bool_count,

                          program->ps_uniforms_bool);