/**

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

    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:1;

    int have_GL_ARB_vertex_program:1;

    int have_GL_ARB_fragment_program:1;

    int have_GL_NV_vertex_program2_option:1;

    int have_GL_NV_fragment_program2:1;

    int have_GL_NV_vertex_program3:1;

    int have_GL_NV_gpu_program4:1;

    int have_GL_ARB_shader_objects:1;

    int have_GL_ARB_vertex_shader:1;

    int have_GL_ARB_fragment_shader:1;

    int have_GL_ARB_shading_language_100:1;

    int have_GL_NV_half_float:1;

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

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

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)

{

    // no-op. ARB1 doesn't have real linked programs.

} // impl_GLSL_DeleteProgram

static GLint impl_ARB1_GetUniformLocation(MOJOSHADER_glProgram *program,

                                          MOJOSHADER_glShader *shader, int idx)

{

    assert(shader->parseData->uniforms[idx].type == MOJOSHADER_UNIFORM_FLOAT);

    return shader->parseData->uniforms[idx].index;  // !!! FIXME: doesn't work if there are int or bool uniforms!

} // impl_ARB1_GetUniformLocation

static GLint impl_ARB1_GetSamplerLocation(MOJOSHADER_glProgram *program,

                                          MOJOSHADER_glShader *shader, int idx)

{

    return shader->parseData->samplers[idx].index;

} // impl_ARB1_GetSamplerLocation

static GLint impl_ARB1_GetAttribLocation(MOJOSHADER_glProgram *program, int idx)

{

    return idx;  // map to vertex arrays in the same order as the parseData.

} // impl_ARB1_GetAttribLocation

static GLuint impl_ARB1_LinkProgram(MOJOSHADER_glShader *vshader,