/**

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

 */

#ifdef _WIN32

#define WIN32_LEAN_AND_MEAN 1

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

#endif

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

#include "TargetConditionals.h"

#if !TARGET_OS_IPHONE && !TARGET_OS_TV

#define PLATFORM_MACOSX 1

#endif /* !TARGET_OS_IPHONE && !TARGET_OS_TV */

#endif /* (defined(__APPLE__) && defined(__MACH__)) */

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

#if SUPPORT_PROFILE_GLSPIRV

#include "spirv/spirv.h"

#endif

#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

// FIXME: ARB_gl_spirv in glext.h? -flibit

#ifndef GL_ARB_gl_spirv

#define GL_ARB_gl_spirv 1

#define GL_SHADER_BINARY_FORMAT_SPIR_V_ARB 0x9551

typedef void (APIENTRYP PFNGLSPECIALIZESHADERARBPROC) (

    GLuint shader,

    const GLchar* pEntryPoint,

    GLuint numSpecializationConstants,

    const GLuint* pConstantIndex,

    const GLuint* pConstantValue

);

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

    uint32 refcount;

    int uses_pointsize;

    // According to MSDN...

    //

    // n is an optional integer between 0 and the number of resources supported.

    //  For example, POSITION0, TEXCOOR1, etc.

    //

    // The input registers consist of 16 four-component floating-point vectors,

    //   designated as v0 through v15.

    GLint vertex_attrib_loc[MOJOSHADER_USAGE_TOTAL][16];

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

    // Numerous fixes for coordinate system mismatches

    GLint ps_vpos_flip_loc;

    int current_vpos_flip[2];

#ifdef MOJOSHADER_FLIP_RENDERTARGET

    GLint vs_flip_loc;

    int current_flip;

#endif

};

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

    // This shadows vertex attribute and divisor states.

    GLuint attr_divisor[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];

#ifdef MOJOSHADER_XNA4_VERTEX_TEXTURES

    // Vertex texture sampler offset...

    int vertex_sampler_offset;

#endif

    // Extensions...

    int have_core_opengl;

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

    int have_opengl_3;  // different extension query.

    int have_opengl_es; // different extension requirements

    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;

    int have_GL_ARB_instanced_arrays;

    int have_GL_ARB_ES2_compatibility;

    int have_GL_ARB_gl_spirv;

    // Entry points...

    PFNGLGETSTRINGPROC glGetString;

    PFNGLGETSTRINGIPROC glGetStringi;

    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;

    PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;

    PFNGLGETSHADERIVPROC glGetShaderiv;

    PFNGLGETPROGRAMIVPROC glGetProgramiv;

    PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation;

    PFNGLLINKPROGRAMPROC glLinkProgram;

    PFNGLSHADERSOURCEPROC glShaderSource;

    PFNGLUNIFORM1IPROC glUniform1i;

    PFNGLUNIFORM1IVPROC glUniform1iv;

    PFNGLUNIFORM2FPROC glUniform2f;

#ifdef MOJOSHADER_FLIP_RENDERTARGET

    PFNGLUNIFORM1FPROC glUniform1f;

#endif

    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;

    PFNGLVERTEXATTRIBDIVISORARBPROC glVertexAttribDivisorARB;

    PFNGLSHADERBINARYPROC glShaderBinary;

    PFNGLSPECIALIZESHADERARBPROC glSpecializeShaderARB;

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

    void (*profileToggleProgramPointSize)(int enable);

};

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)

{

#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1050

    return 1;

#else

    static int checked = 0;

    static int combined = 0;

    if (!checked)

    {

        SInt32 ver = 0;

        SInt32 major = 0;

        SInt32 minor = 0;

        SInt32 patch = 0;

        int convert = 0;

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

        {

            ver = 0x1000;  // oh well.

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

        }

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

#endif

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

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?

    assert(0 && "Unknown GLSL shader type!");

    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

#if SUPPORT_PROFILE_GLSPIRV

static const SpirvPatchTable* spv_getPatchTable(MOJOSHADER_glShader *shader)

{

    const MOJOSHADER_parseData *pd = shader->parseData;

    size_t table_offset = pd->output_len - sizeof(SpirvPatchTable);

    return (const SpirvPatchTable *) (pd->output + table_offset);

} // spv_getPatchTable

static int spv_CompileShader(const MOJOSHADER_parseData *pd, int32 base_location, GLuint *s, int32 patch_pcoord)

{

    GLint ok = 0;

    GLsizei data_len = pd->output_len - sizeof(SpirvPatchTable);

    const GLvoid* data = pd->output;

    uint32 *patched_data = NULL;

    if (base_location || patch_pcoord)

    {

        size_t i, max;

        patched_data = (uint32 *) Malloc(data_len);

        memcpy(patched_data, data, data_len);

        const SpirvPatchTable *table = (const SpirvPatchTable *) &pd->output[data_len];

        if (table->vpflip.offset)      patched_data[table->vpflip.offset]      += base_location;

        if (table->array_vec4.offset)  patched_data[table->array_vec4.offset]  += base_location;

        if (table->array_ivec4.offset) patched_data[table->array_ivec4.offset] += base_location;

        if (table->array_bool.offset)  patched_data[table->array_bool.offset]  += base_location;

        for (i = 0, max = STATICARRAYLEN(table->samplers); i < max; i++)

        {

            SpirvPatchEntry entry = table->samplers[i];

            if (entry.offset)

                patched_data[entry.offset] += base_location;

        } // for

        if (patch_pcoord && table->ps_texcoord0_offset)

        {

            // Subtract 3 to get from Location value offset to start of op.

            uint32 op_base = table->ps_texcoord0_offset - 3;

            assert(patched_data[op_base+0] == (SpvOpDecorate | (4 << 16)));

            assert(patched_data[op_base+2] == SpvDecorationLocation);

            patched_data[op_base+2] = SpvDecorationBuiltIn;

            patched_data[op_base+3] = SpvBuiltInPointCoord;

        } // if