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

#ifndef MOJOSHADER_PROFILE_SPIRV_H
#define MOJOSHADER_PROFILE_SPIRV_H

#if SUPPORT_PROFILE_SPIRV

#define MOJOSHADER_SPIRV_VS_SAMPLER_SET 0
#define MOJOSHADER_SPIRV_PS_SAMPLER_SET 1
#define MOJOSHADER_SPIRV_VS_UNIFORM_SET 2
#define MOJOSHADER_SPIRV_PS_UNIFORM_SET 3

// For baked-in constants in SPIR-V we want to store scalar values that we can
// use in composites, since OpConstantComposite uses result ids constituates
// rather than value literals.
// We'll store these lists grouped by type and have the lists themselves
// ordered by value in the ctx.spirv struct.
typedef struct ComponentList
{
    // result id from OpConstant
    uint32 id;
    union {
        float f;
        int i;
        uint32 u;
    } v;
    struct ComponentList *next;
} ComponentList;

typedef struct SpirvLoopInfo
{
    uint32 tid_counter;
    uint32 id_counter;
    uint32 id_counter_next;
    uint32 id_aL;
    uint32 id_label_header;
    uint32 id_label_continue;
    uint32 id_label_merge;
} SpirvLoopInfo;

typedef enum SpirvType
{
    ST_FLOAT = 0,
    ST_SINT = 1,
    ST_UINT = 2,
    ST_BOOL = 3,
} SpirvType;

typedef enum SpirvStorageClass
{
    SC_INPUT = 0,
    SC_OUTPUT = 1,
    SC_PRIVATE = 2,
    SC_UNIFORM_CONSTANT = 3,
} SpirvStorageClass;

/* Not all type parameter combinations are actually used, but it's all rounded up to 64 so
 * it's easier to work with.
 */
typedef enum SpirvTypeIdx
{
    STI_VOID          = 0,
    STI_FUNC_VOID     = 1,
    STI_FUNC_LIT      = 2,
    STI_IMAGE2D       = 3,
    STI_IMAGE3D       = 4,
    STI_IMAGECUBE     = 5,
    STI_PTR_IMAGE2D   = 6,
    STI_PTR_IMAGE3D   = 7,
    STI_PTR_IMAGECUBE = 8,

    // 7 unused entries

    // 4 base types * 4 vector sizes = 16 entries
    STI_FLOAT = (0 << 5) | (1 << 4) | (ST_FLOAT << 2) | 0,
    STI_VEC2  = (0 << 5) | (1 << 4) | (ST_FLOAT << 2) | 1,
    STI_VEC3  = (0 << 5) | (1 << 4) | (ST_FLOAT << 2) | 2,
    STI_VEC4  = (0 << 5) | (1 << 4) | (ST_FLOAT << 2) | 3,
    STI_INT   = (0 << 5) | (1 << 4) | (ST_SINT  << 2) | 0,
    STI_IVEC2 = (0 << 5) | (1 << 4) | (ST_SINT  << 2) | 1,
    STI_IVEC3 = (0 << 5) | (1 << 4) | (ST_SINT  << 2) | 2,
    STI_IVEC4 = (0 << 5) | (1 << 4) | (ST_SINT  << 2) | 3,
    STI_UINT  = (0 << 5) | (1 << 4) | (ST_UINT  << 2) | 0,
    STI_UVEC2 = (0 << 5) | (1 << 4) | (ST_UINT  << 2) | 1,
    STI_UVEC3 = (0 << 5) | (1 << 4) | (ST_UINT  << 2) | 2,
    STI_UVEC4 = (0 << 5) | (1 << 4) | (ST_UINT  << 2) | 3,
    STI_BOOL  = (0 << 5) | (1 << 4) | (ST_BOOL  << 2) | 0,
    STI_BVEC2 = (0 << 5) | (1 << 4) | (ST_BOOL  << 2) | 1,
    STI_BVEC3 = (0 << 5) | (1 << 4) | (ST_BOOL  << 2) | 2,
    STI_BVEC4 = (0 << 5) | (1 << 4) | (ST_BOOL  << 2) | 3,

    // 2 dims (vec4 + scalar) * 4 base types * 4 storage classes
    STI_PTR_FLOAT_I = (1 << 5) | (0 << 4) | (ST_FLOAT << 2) | SC_INPUT,
    STI_PTR_FLOAT_O = (1 << 5) | (0 << 4) | (ST_FLOAT << 2) | SC_OUTPUT,
    STI_PTR_FLOAT_P = (1 << 5) | (0 << 4) | (ST_FLOAT << 2) | SC_PRIVATE,
    STI_PTR_FLOAT_U = (1 << 5) | (0 << 4) | (ST_FLOAT << 2) | SC_UNIFORM_CONSTANT,
    STI_PTR_INT_I   = (1 << 5) | (0 << 4) | (ST_SINT  << 2) | SC_INPUT,
    STI_PTR_INT_O   = (1 << 5) | (0 << 4) | (ST_SINT  << 2) | SC_OUTPUT,
    STI_PTR_INT_P   = (1 << 5) | (0 << 4) | (ST_SINT  << 2) | SC_PRIVATE,
    STI_PTR_INT_U   = (1 << 5) | (0 << 4) | (ST_SINT  << 2) | SC_UNIFORM_CONSTANT,
    STI_PTR_UINT_I  = (1 << 5) | (0 << 4) | (ST_UINT  << 2) | SC_INPUT,
    STI_PTR_UINT_O  = (1 << 5) | (0 << 4) | (ST_UINT  << 2) | SC_OUTPUT,
    STI_PTR_UINT_P  = (1 << 5) | (0 << 4) | (ST_UINT  << 2) | SC_PRIVATE,
    STI_PTR_UINT_U  = (1 << 5) | (0 << 4) | (ST_UINT  << 2) | SC_UNIFORM_CONSTANT,
    STI_PTR_BOOL_I  = (1 << 5) | (0 << 4) | (ST_BOOL  << 2) | SC_INPUT,
    STI_PTR_BOOL_O  = (1 << 5) | (0 << 4) | (ST_BOOL  << 2) | SC_OUTPUT,
    STI_PTR_BOOL_P  = (1 << 5) | (0 << 4) | (ST_BOOL  << 2) | SC_PRIVATE,
    STI_PTR_BOOL_U  = (1 << 5) | (0 << 4) | (ST_BOOL  << 2) | SC_UNIFORM_CONSTANT,
    STI_PTR_VEC4_I  = (1 << 5) | (1 << 4) | (ST_FLOAT << 2) | SC_INPUT,
    STI_PTR_VEC4_O  = (1 << 5) | (1 << 4) | (ST_FLOAT << 2) | SC_OUTPUT,
    STI_PTR_VEC4_P  = (1 << 5) | (1 << 4) | (ST_FLOAT << 2) | SC_PRIVATE,
    STI_PTR_VEC4_U  = (1 << 5) | (1 << 4) | (ST_FLOAT << 2) | SC_UNIFORM_CONSTANT,
    STI_PTR_IVEC4_I = (1 << 5) | (1 << 4) | (ST_SINT  << 2) | SC_INPUT,
    STI_PTR_IVEC4_O = (1 << 5) | (1 << 4) | (ST_SINT  << 2) | SC_OUTPUT,
    STI_PTR_IVEC4_P = (1 << 5) | (1 << 4) | (ST_SINT  << 2) | SC_PRIVATE,
    STI_PTR_IVEC4_U = (1 << 5) | (1 << 4) | (ST_SINT  << 2) | SC_UNIFORM_CONSTANT,
    STI_PTR_UVEC4_I = (1 << 5) | (1 << 4) | (ST_UINT  << 2) | SC_INPUT,
    STI_PTR_UVEC4_O = (1 << 5) | (1 << 4) | (ST_UINT  << 2) | SC_OUTPUT,
    STI_PTR_UVEC4_P = (1 << 5) | (1 << 4) | (ST_UINT  << 2) | SC_PRIVATE,
    STI_PTR_UVEC4_U = (1 << 5) | (1 << 4) | (ST_UINT  << 2) | SC_UNIFORM_CONSTANT,
    STI_PTR_BVEC4_I = (1 << 5) | (1 << 4) | (ST_BOOL  << 2) | SC_INPUT,
    STI_PTR_BVEC4_O = (1 << 5) | (1 << 4) | (ST_BOOL  << 2) | SC_OUTPUT,
    STI_PTR_BVEC4_P = (1 << 5) | (1 << 4) | (ST_BOOL  << 2) | SC_PRIVATE,
    STI_PTR_BVEC4_U = (1 << 5) | (1 << 4) | (ST_BOOL  << 2) | SC_UNIFORM_CONSTANT,

    // 2 + 6 + 16 + 32 = 56 entries (+ 8 unused)

    // Helpers
    STI_LENGTH_,

    STI_MISC_START_ = 0,
    STI_MISC_END_   = 8,
    STI_CORE_START_ = (0 << 5) | (1 << 4),
    STI_PTR_START_  = (1 << 5) | (0 << 4),
    STI_CORE_END_   = STI_PTR_START_,
    STI_PTR_END_    = STI_LENGTH_,
} SpirvTypeIdx;

// In addition to result ID we also need type ID (can't assume everything is vec4).
typedef struct SpirvResult
{
    uint32 tid;
    uint32 id;
} SpirvResult;

// This doesn't 100% correspond to glslangValidator semantics. It just says which mode to use at
// runtime (different from compile-time support being enabled). Technically, we could generate the
// same for both, but that would require GL code to use UBOs.
typedef enum SpirvMode
{
    SPIRV_MODE_GL,
    SPIRV_MODE_VK,
} SpirvMode;

typedef struct SpirvContext
{
#if SUPPORT_PROFILE_GLSPIRV
    uint32 id_vs_main_end;
#endif // SUPPORT_PROFILE_GLSPIRV
    SpirvMode mode;
    // ext. glsl instructions have been imported
    uint32 idext;
    uint32 idmax;
    uint32 idmain;
    uint32 id_func_lit;
    uint32 inoutcount;
    uint32 id_var_fragcoord;
    uint32 id_var_vpos;
    uint32 id_var_frontfacing;
    uint32 id_var_vface;
    // ids for types so we can reuse them after they're declared
    uint32 tid[STI_LENGTH_];
    uint32 idtrue;
    uint32 idfalse;
    uint32 id_0_0[4];
    uint32 id_0_125[4];
    uint32 id_0_25[4];
    uint32 id_0_5[4];
    uint32 id_1_0[4];
    uint32 id_2_0[4];
    uint32 id_4_0[4];
    uint32 id_8_0[4];
    uint32 id_flt_max[4];
    struct {
        uint32 idvec4;
        uint32 idivec4;
        uint32 idbool;
    } uniform_arrays;
    uint32 id_uniform_block;
    struct {
        uint32 idvec4;
    } constant_arrays;
    struct {
        ComponentList f;
        ComponentList i;
        ComponentList u;
    } cl;

    SpirvPatchTable patch_table;

    // Required only on ps_1_3 and below, which only has 4 registers for this purpose.
    struct {
        uint32 idtexbem;
        uint32 idtexbeml;
    } sampler_extras[4];

    // TEX opcode in ps_1_3 and below has one implicit texcoord input attribute for each texture
    // register. We use this array to hold SSA id of this input attribute (see emit_SPIRV_global
    // for details).
    uint32 id_implicit_input[4];

    int loop_stack_idx;
    SpirvLoopInfo loop_stack[32];
} SpirvContext;

#endif // if SUPPORT_PROFILE_SPIRV

#endif