/**

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

 */

// !!! FIXME: preshaders shouldn't be handled in here at all. This should

// !!! FIXME:  be in the Effects API, once that's actually written.

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

#define GL_HALF_FLOAT_NV 0x140B

#endif

#ifndef GL_HALF_FLOAT_ARB

#define GL_HALF_FLOAT_ARB 0x140B

#endif

#ifndef GL_HALF_FLOAT_OES

#define GL_HALF_FLOAT_OES 0x8D61

#endif

// this happens to be the same value for ARB1 and GLSL.

#ifndef GL_PROGRAM_POINT_SIZE

#define GL_PROGRAM_POINT_SIZE 0x8642

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

    uint32 texbem_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;

    size_t vs_preshader_reg_count;

    GLfloat *vs_preshader_regs;

    size_t ps_preshader_reg_count;

    GLfloat *ps_preshader_regs;

    uint32 refcount;

    int uses_pointsize;

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

#define MAX_TEXBEMS 3  // ps_1_1 allows 4 texture stages, texbem can't use t0.

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

    GLfloat texbem_state[MAX_TEXBEMS * 6];

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

    uint32 generation;

    // This keeps track of implicitly linked programs.

    HashTable *linker_cache;

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

    GLint max_attrs;

    uint8 want_attr[32];

    uint8 have_attr[32];

    // rarely used, so we don't touch when we don't have to.

    int pointsize_enabled;

    // GL stuff...

    int opengl_major;

    int opengl_minor;

    int glsl_major;

    int glsl_minor;

    MOJOSHADER_glProgram *bound_program;

    char profile[16];

    // Extensions...

    int have_core_opengl;

    int have_opengl_2;  // different entry points than ARB extensions.

    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;

    PFNGLDELETESHADERPROC glDeleteShader;

    PFNGLDELETEPROGRAMPROC glDeleteProgram;

    PFNGLATTACHSHADERPROC glAttachShader;

    PFNGLCOMPILESHADERPROC glCompileShader;

    PFNGLCREATESHADERPROC glCreateShader;

    PFNGLCREATEPROGRAMPROC glCreateProgram;

    PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray;

    PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray;

    PFNGLGETATTRIBLOCATIONPROC glGetAttribLocation;

    PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog;

    PFNGLGETSHADERIVPROC glGetShaderiv;

    PFNGLGETPROGRAMIVPROC glGetProgramiv;

    PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation;

    PFNGLLINKPROGRAMPROC glLinkProgram;

    PFNGLSHADERSOURCEPROC glShaderSource;

    PFNGLUNIFORM1IPROC glUniform1i;

    PFNGLUNIFORM1IVPROC glUniform1iv;

    PFNGLUNIFORM4FVPROC glUniform4fv;

    PFNGLUNIFORM4IVPROC glUniform4iv;

    PFNGLUSEPROGRAMPROC glUseProgram;

    PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer;

    PFNGLDELETEOBJECTARBPROC glDeleteObjectARB;

    PFNGLATTACHOBJECTARBPROC glAttachObjectARB;

    PFNGLCOMPILESHADERARBPROC glCompileShaderARB;

    PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB;

    PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB;

    PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArrayARB;

    PFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArrayARB;

    PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB;

    PFNGLGETINFOLOGARBPROC glGetInfoLogARB;

    PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB;

    PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB;

    PFNGLLINKPROGRAMARBPROC glLinkProgramARB;

    PFNGLSHADERSOURCEARBPROC glShaderSourceARB;

    PFNGLUNIFORM1IARBPROC glUniform1iARB;

    PFNGLUNIFORM1IVARBPROC glUniform1ivARB;

    PFNGLUNIFORM4FVARBPROC glUniform4fvARB;

    PFNGLUNIFORM4IVARBPROC glUniform4ivARB;

    PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB;

    PFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointerARB;

    PFNGLGETPROGRAMIVARBPROC glGetProgramivARB;

    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 (*profileUseProgram)(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 out_of_memory(void)

{

    set_error("out of memory");

} // out_of_memory

static inline void *Malloc(const size_t len)

{

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

    if (retval == NULL)

        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)

{

    // these enums match between core 2.0 and the ARB extensions.

    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)

{

    // these enums match between core 2.0 and the ARB extensions.

    GLenum pname = GL_NONE;

    GLint val = 0;

    if (shader_type == MOJOSHADER_TYPE_VERTEX)

        pname = GL_MAX_VERTEX_UNIFORM_COMPONENTS;

    else if (shader_type == MOJOSHADER_TYPE_PIXEL)

        pname = GL_MAX_FRAGMENT_UNIFORM_COMPONENTS;

    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;

    const GLint codelen = (GLint) pd->output_len;

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

    if (ctx->have_opengl_2)

    {

        const GLuint shader = ctx->glCreateShader(shader_type);

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

        ctx->glCompileShader(shader);

        ctx->glGetShaderiv(shader, GL_COMPILE_STATUS, &ok);

        if (!ok)

        {

            GLsizei len = 0;

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

                                 (GLchar *) error_buffer);

            *s = 0;

            return 0;

        } // if

        *s = shader;

    } // if

    else

    {

        const GLhandleARB shader = ctx->glCreateShaderObjectARB(shader_type);

        assert(sizeof (shader) == sizeof (*s));  // not always true on OS X!

        ctx->glShaderSourceARB(shader, 1,

                              (const GLcharARB **) &pd->output, &codelen);

        ctx->glCompileShaderARB(shader);

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

        if (!ok)

        {

            GLsizei len = 0;

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

                                 (GLcharARB *) error_buffer);

            *s = 0;

            return 0;

        } // if

        *s = (GLuint) shader;

    } // else

    return 1;

} // impl_GLSL_CompileShader

static void impl_GLSL_DeleteShader(const GLuint shader)

{

    if (ctx->have_opengl_2)

        ctx->glDeleteShader(shader);

    else

        ctx->glDeleteObjectARB((GLhandleARB) shader);

} // impl_GLSL_DeleteShader

static void impl_GLSL_DeleteProgram(const GLuint program)

{

    if (ctx->have_opengl_2)

        ctx->glDeleteProgram(program);

    else

        ctx->glDeleteObjectARB((GLhandleARB) 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 inline GLint glsl_uniform_loc(MOJOSHADER_glProgram *program,

                                          const char *name)

{

    return ctx->have_opengl_2 ?

        ctx->glGetUniformLocation(program->handle, name) :

        ctx->glGetUniformLocationARB((GLhandleARB) program->handle, name);

} // glsl_uniform_loc

static GLint impl_GLSL_GetSamplerLocation(MOJOSHADER_glProgram *program,

                                          MOJOSHADER_glShader *shader, int idx)

{

    return glsl_uniform_loc(program, 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;

    if (ctx->have_opengl_2)

    {

        return ctx->glGetAttribLocation(program->handle,

                                        (const GLchar *) a[idx].name);

    } // if

    return ctx->glGetAttribLocationARB((GLhandleARB) program->handle,

                                        (const GLcharARB *) a[idx].name);

} // impl_GLSL_GetAttribLocation