/**

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

 */

#define __MOJOSHADER_INTERNAL__ 1

#include "mojoshader_profile.h"

#pragma GCC visibility push(hidden)

// !!! FIXME: A lot of this is cut-and-paste from the GLSL/Metal versions.

#if SUPPORT_PROFILE_HLSL

#define EMIT_HLSL_OPCODE_UNIMPLEMENTED_FUNC(op) \

    void emit_HLSL_##op(Context *ctx) { \

        fail(ctx, #op " unimplemented in hlsl profile"); \

    }

static inline const char *get_HLSL_register_string(Context *ctx,

                        const RegisterType regtype, const int regnum,

                        char *regnum_str, const size_t regnum_size)

{

    // turns out these are identical at the moment.

    return get_D3D_register_string(ctx,regtype,regnum,regnum_str,regnum_size);

} // get_HLSL_register_string

const char *get_HLSL_uniform_type(Context *ctx, const RegisterType rtype)

{

    switch (rtype)

    {

        case REG_TYPE_CONST: return "float4";

        case REG_TYPE_CONSTINT: return "int4";

        case REG_TYPE_CONSTBOOL: return "bool";

        default: fail(ctx, "BUG: used a uniform we don't know how to define.");

    } // switch

    return NULL;

} // get_HLSL_uniform_type

const char *get_HLSL_varname_in_buf(Context *ctx, RegisterType rt,

                                    int regnum, char *buf,

                                    const size_t len)

{

    char regnum_str[16];

    const char *regtype_str = get_HLSL_register_string(ctx, rt, regnum,

                                              regnum_str, sizeof (regnum_str));

    snprintf(buf,len,"%s%s", regtype_str, regnum_str);

    return buf;

} // get_HLSL_varname_in_buf

const char *get_HLSL_varname(Context *ctx, RegisterType rt, int regnum)

{

    char buf[64];

    get_HLSL_varname_in_buf(ctx, rt, regnum, buf, sizeof(buf));

    return StrDup(ctx, buf);

} // get_HLSL_varname

static inline const char *get_HLSL_const_array_varname_in_buf(Context *ctx,

                                                const int base, const int size,

                                                char *buf, const size_t buflen)

{

    snprintf(buf, buflen, "const_array_%d_%d", base, size);

    return buf;

} // get_HLSL_const_array_varname_in_buf

const char *get_HLSL_const_array_varname(Context *ctx, int base, int size)

{

    char buf[64];

    get_HLSL_const_array_varname_in_buf(ctx, base, size, buf, sizeof(buf));

    return StrDup(ctx, buf);

} // get_HLSL_const_array_varname

static inline const char *get_HLSL_input_array_varname(Context *ctx,

                                                char *buf, const size_t buflen)

{

    snprintf(buf, buflen, "%s", "vertex_input_array");

    return buf;

} // get_HLSL_input_array_varname

const char *get_HLSL_uniform_array_varname(Context *ctx,

                                           const RegisterType regtype,

                                           char *buf, const size_t len)

{

    const char *type = get_HLSL_uniform_type(ctx, regtype);

    snprintf(buf, len, "uniforms_%s", type);

    return buf;

} // get_HLSL_uniform_array_varname

const char *get_HLSL_destarg_varname(Context *ctx, char *buf, size_t len)

{

    const DestArgInfo *arg = &ctx->dest_arg;

    return get_HLSL_varname_in_buf(ctx, arg->regtype, arg->regnum, buf, len);

} // get_HLSL_destarg_varname

const char *get_HLSL_srcarg_varname(Context *ctx, const size_t idx,

                                    char *buf, size_t len)

{

    if (idx >= STATICARRAYLEN(ctx->source_args))

    {

        fail(ctx, "Too many source args");

        *buf = '\0';

        return buf;

    } // if

    const SourceArgInfo *arg = &ctx->source_args[idx];

    return get_HLSL_varname_in_buf(ctx, arg->regtype, arg->regnum, buf, len);

} // get_HLSL_srcarg_varname

const char *make_HLSL_destarg_assign(Context *, char *, const size_t,

                                     const char *, ...) ISPRINTF(4,5);

const char *make_HLSL_destarg_assign(Context *ctx, char *buf,

                                     const size_t buflen,

                                     const char *fmt, ...)

{

    int need_parens = 0;

    const DestArgInfo *arg = &ctx->dest_arg;

    if (arg->writemask == 0)

    {

        *buf = '\0';

        return buf;  // no writemask? It's a no-op.

    } // if

    const char *clampleft = "";

    const char *clampright = "";

    if (arg->result_mod & MOD_SATURATE)

    {

        clampleft = "saturate(";

        clampright = ")";

    } // if

    // MSDN says MOD_PP is a hint and many implementations ignore it. So do we.

    // CENTROID only allowed in DCL opcodes, which shouldn't come through here.

    assert((arg->result_mod & MOD_CENTROID) == 0);

    if (ctx->predicated)

    {

        fail(ctx, "predicated destinations unsupported");  // !!! FIXME

        *buf = '\0';

        return buf;

    } // if

    char operation[256];

    va_list ap;

    va_start(ap, fmt);

    const int len = vsnprintf(operation, sizeof (operation), fmt, ap);

    va_end(ap);

    if (len >= sizeof (operation))

    {

        fail(ctx, "operation string too large");  // I'm lazy.  :P

        *buf = '\0';

        return buf;

    } // if

    const char *result_shift_str = "";

    switch (arg->result_shift)

    {

        case 0x1: result_shift_str = " * 2.0"; break;

        case 0x2: result_shift_str = " * 4.0"; break;

        case 0x3: result_shift_str = " * 8.0"; break;

        case 0xD: result_shift_str = " / 8.0"; break;

        case 0xE: result_shift_str = " / 4.0"; break;

        case 0xF: result_shift_str = " / 2.0"; break;

    } // switch

    need_parens |= (result_shift_str[0] != '\0');

    char regnum_str[16];

    const char *regtype_str = get_HLSL_register_string(ctx, arg->regtype,

                                                       arg->regnum, regnum_str,

                                                       sizeof (regnum_str));

    char writemask_str[6];

    size_t i = 0;

    const int scalar = isscalar(ctx, ctx->shader_type, arg->regtype, arg->regnum);

    if (!scalar && !writemask_xyzw(arg->writemask))

    {

        writemask_str[i++] = '.';

        if (arg->writemask0) writemask_str[i++] = 'x';

        if (arg->writemask1) writemask_str[i++] = 'y';

        if (arg->writemask2) writemask_str[i++] = 'z';

        if (arg->writemask3) writemask_str[i++] = 'w';

    } // if

    writemask_str[i] = '\0';

    assert(i < sizeof (writemask_str));

    const char *leftparen = (need_parens) ? "(" : "";

    const char *rightparen = (need_parens) ? ")" : "";

    snprintf(buf, buflen, "%s%s%s = %s%s%s%s%s%s;", regtype_str,

             regnum_str, writemask_str,clampleft, leftparen,

             operation, rightparen, result_shift_str, clampright);

    // !!! FIXME: make sure the scratch buffer was large enough.

    return buf;

} // make_HLSL_destarg_assign

char *make_HLSL_swizzle_string(char *swiz_str, const size_t strsize,

                               const int swizzle, const int writemask)

{

    size_t i = 0;

    if ( (!no_swizzle(swizzle)) || (!writemask_xyzw(writemask)) )

    {

        const int writemask0 = (writemask >> 0) & 0x1;

        const int writemask1 = (writemask >> 1) & 0x1;

        const int writemask2 = (writemask >> 2) & 0x1;

        const int writemask3 = (writemask >> 3) & 0x1;

        const int swizzle_x = (swizzle >> 0) & 0x3;

        const int swizzle_y = (swizzle >> 2) & 0x3;

        const int swizzle_z = (swizzle >> 4) & 0x3;

        const int swizzle_w = (swizzle >> 6) & 0x3;

        swiz_str[i++] = '.';

        if (writemask0) swiz_str[i++] = swizzle_channels[swizzle_x];

        if (writemask1) swiz_str[i++] = swizzle_channels[swizzle_y];

        if (writemask2) swiz_str[i++] = swizzle_channels[swizzle_z];

        if (writemask3) swiz_str[i++] = swizzle_channels[swizzle_w];

    } // if

    assert(i < strsize);

    swiz_str[i] = '\0';

    return swiz_str;

} // make_HLSL_swizzle_string

const char *make_HLSL_srcarg_string(Context *ctx, const size_t idx,

                                    const int writemask, char *buf,

                                    const size_t buflen)

{

    *buf = '\0';

    if (idx >= STATICARRAYLEN(ctx->source_args))

    {

        fail(ctx, "Too many source args");

        return buf;

    } // if

    const SourceArgInfo *arg = &ctx->source_args[idx];

    const char *premod_str = "";

    const char *postmod_str = "";

    switch (arg->src_mod)

    {

        case SRCMOD_NEGATE:

            premod_str = "-";

            break;

        case SRCMOD_BIASNEGATE:

            premod_str = "-(";

            postmod_str = " - 0.5)";

            break;

        case SRCMOD_BIAS:

            premod_str = "(";

            postmod_str = " - 0.5)";

            break;

        case SRCMOD_SIGNNEGATE:

            premod_str = "-((";

            postmod_str = " - 0.5) * 2.0)";

            break;

        case SRCMOD_SIGN:

            premod_str = "((";

            postmod_str = " - 0.5) * 2.0)";

            break;

        case SRCMOD_COMPLEMENT:

            premod_str = "(1.0 - ";

            postmod_str = ")";

            break;

        case SRCMOD_X2NEGATE:

            premod_str = "-(";

            postmod_str = " * 2.0)";

            break;

        case SRCMOD_X2:

            premod_str = "(";

            postmod_str = " * 2.0)";

            break;

        case SRCMOD_DZ:

            fail(ctx, "SRCMOD_DZ unsupported"); return buf; // !!! FIXME

            postmod_str = "_dz";

            break;

        case SRCMOD_DW:

            fail(ctx, "SRCMOD_DW unsupported"); return buf; // !!! FIXME

            postmod_str = "_dw";

            break;

        case SRCMOD_ABSNEGATE:

            premod_str = "-abs(";

            postmod_str = ")";

            break;

        case SRCMOD_ABS:

            premod_str = "abs(";

            postmod_str = ")";

            break;

        case SRCMOD_NOT:

            premod_str = "!";

            break;

        case SRCMOD_NONE:

        case SRCMOD_TOTAL:

             break;  // stop compiler whining.

    } // switch

    const char *regtype_str = NULL;

    if (!arg->relative)

    {

        regtype_str = get_HLSL_varname_in_buf(ctx, arg->regtype, arg->regnum,

                                              (char *) alloca(64), 64);

    } // if

    const char *rel_lbracket = "";

    char rel_offset[32] = { '\0' };

    const char *rel_rbracket = "";

    char rel_swizzle[4] = { '\0' };

    const char *rel_regtype_str = "";

    if (arg->relative)

    {

        if (arg->regtype == REG_TYPE_INPUT)

            regtype_str=get_HLSL_input_array_varname(ctx,(char*)alloca(64),64);

        else

        {

            assert(arg->regtype == REG_TYPE_CONST);

            const int arrayidx = arg->relative_array->index;

            const int offset = arg->regnum - arrayidx;

            assert(offset >= 0);

            if (arg->relative_array->constant)

            {

                const int arraysize = arg->relative_array->count;

                regtype_str = get_HLSL_const_array_varname_in_buf(ctx,

                                arrayidx, arraysize, (char *) alloca(64), 64);

                if (offset != 0)

                    snprintf(rel_offset, sizeof (rel_offset), "%d + ", offset);

            } // if

            else

            {

                regtype_str = get_HLSL_uniform_array_varname(ctx, arg->regtype,

                                                      (char *) alloca(64), 64);

                if (offset == 0)

                {

                    snprintf(rel_offset, sizeof (rel_offset),

                             "ARRAYBASE_%d + ", arrayidx);

                } // if

                else

                {

                    snprintf(rel_offset, sizeof (rel_offset),

                             "(ARRAYBASE_%d + %d) + ", arrayidx, offset);

                } // else

            } // else

        } // else

        rel_lbracket = "[";

        rel_regtype_str = get_HLSL_varname_in_buf(ctx, arg->relative_regtype,

                                                    arg->relative_regnum,

                                                    (char *) alloca(64), 64);

        rel_swizzle[0] = '.';

        rel_swizzle[1] = swizzle_channels[arg->relative_component];

        rel_swizzle[2] = '\0';

        rel_rbracket = "]";

    } // if

    char swiz_str[6] = { '\0' };

    if (!isscalar(ctx, ctx->shader_type, arg->regtype, arg->regnum))

    {

        make_HLSL_swizzle_string(swiz_str, sizeof (swiz_str),

                                 arg->swizzle, writemask);

    } // if

    if (regtype_str == NULL)

    {

        fail(ctx, "Unknown source register type.");

        return buf;

    } // if

    snprintf(buf, buflen, "%s%s%s%s%s%s%s%s%s",

             premod_str, regtype_str, rel_lbracket, rel_offset,

             rel_regtype_str, rel_swizzle, rel_rbracket, swiz_str,

             postmod_str);

    // !!! FIXME: make sure the scratch buffer was large enough.

    return buf;

} // make_HLSL_srcarg_string

// generate some convenience functions.

#define MAKE_HLSL_SRCARG_STRING_(mask, bitmask) \

    static inline const char *make_HLSL_srcarg_string_##mask(Context *ctx, \

                                                const size_t idx, char *buf, \

                                                const size_t buflen) { \

        return make_HLSL_srcarg_string(ctx, idx, bitmask, buf, buflen); \

    }

MAKE_HLSL_SRCARG_STRING_(x, (1 << 0))

MAKE_HLSL_SRCARG_STRING_(y, (1 << 1))

MAKE_HLSL_SRCARG_STRING_(z, (1 << 2))

MAKE_HLSL_SRCARG_STRING_(w, (1 << 3))

MAKE_HLSL_SRCARG_STRING_(scalar, (1 << 0))

MAKE_HLSL_SRCARG_STRING_(full, 0xF)

MAKE_HLSL_SRCARG_STRING_(masked, ctx->dest_arg.writemask)

MAKE_HLSL_SRCARG_STRING_(vec3, 0x7)

MAKE_HLSL_SRCARG_STRING_(vec2, 0x3)

#undef MAKE_HLSL_SRCARG_STRING_

// special cases for comparison opcodes...

const char *get_HLSL_comparison_string_scalar(Context *ctx)

{

    const char *comps[] = { "", ">", "==", ">=", "<", "!=", "<=" };

    if (ctx->instruction_controls >= STATICARRAYLEN(comps))

    {

        fail(ctx, "unknown comparison control");

        return "";

    } // if

    return comps[ctx->instruction_controls];

} // get_HLSL_comparison_string_scalar

const char *get_HLSL_comparison_string_vector(Context *ctx)

{

    return get_HLSL_comparison_string_scalar(ctx); // standard C operators work for vectors in HLSL.

} // get_HLSL_comparison_string_vector

void emit_HLSL_start(Context *ctx, const char *profilestr)

{

    if (!shader_is_vertex(ctx) && !shader_is_pixel(ctx))

    {

        failf(ctx, "Shader type %u unsupported in this profile.",

              (uint) ctx->shader_type);

        return;

    } // if

    if (!ctx->mainfn)

    {

        if (shader_is_vertex(ctx))

            ctx->mainfn = StrDup(ctx, "VertexShader");

        else if (shader_is_pixel(ctx))

            ctx->mainfn = StrDup(ctx, "PixelShader");

    } // if

    set_output(ctx, &ctx->mainline);

    ctx->indent++;

} // emit_HLSL_start

void emit_HLSL_RET(Context *ctx);

void emit_HLSL_end(Context *ctx)

{

    // !!! FIXME: maybe handle this at a higher level?

    // ps_1_* writes color to r0 instead oC0. We move it to the right place.

    // We don't have to worry about a RET opcode messing this up, since

    //  RET isn't available before ps_2_0.

    if (shader_is_pixel(ctx) && !shader_version_atleast(ctx, 2, 0))

    {

        set_used_register(ctx, REG_TYPE_COLOROUT, 0, 1);

        output_line(ctx, "oC0 = r0;");

    } // if

    // !!! FIXME: maybe handle this at a higher level?

    // force a RET opcode if we're at the end of the stream without one.

    if (ctx->previous_opcode != OPCODE_RET)

        emit_HLSL_RET(ctx);

} // emit_HLSL_end

void emit_HLSL_phase(Context *ctx)

{

    // no-op in HLSL.

} // emit_HLSL_phase

void output_HLSL_uniform_array(Context *ctx, const RegisterType regtype,

                               const int size)

{

    if (size > 0)

    {

        char buf[64];

        get_HLSL_uniform_array_varname(ctx, regtype, buf, sizeof (buf));

        const char *typ;

        switch (regtype)

        {

            case REG_TYPE_CONST: typ = "float4"; break;

            case REG_TYPE_CONSTINT: typ = "int4"; break;

            case REG_TYPE_CONSTBOOL: typ = "bool"; break;

            default:

            {

                fail(ctx, "BUG: used a uniform we don't know how to define.");

                return;

            } // default

        } // switch

        output_line(ctx, "%s %s[%d];", typ, buf, size);

    } // if

} // output_HLSL_uniform_array

void emit_HLSL_finalize(Context *ctx)

{

    if (ctx->have_relative_input_registers) // !!! FIXME

        fail(ctx, "Relative addressing of input registers not supported.");

    // Check uniform_float4_count too since TEXBEM affects it

    if (ctx->uniform_count > 0 || ctx->uniform_float4_count > 0)

    {

        push_output(ctx, &ctx->preflight);

        output_line(ctx, "cbuffer %s_Uniforms : register(b0)", ctx->mainfn);

        output_line(ctx, "{");

        ctx->indent++;

        output_HLSL_uniform_array(ctx, REG_TYPE_CONST, ctx->uniform_float4_count);

        output_HLSL_uniform_array(ctx, REG_TYPE_CONSTINT, ctx->uniform_int4_count);

        output_HLSL_uniform_array(ctx, REG_TYPE_CONSTBOOL, ctx->uniform_bool_count);

        ctx->indent--;

        output_line(ctx, "};");

        output_blank_line(ctx);

        pop_output(ctx);

    } // if

    // Fill in the shader's mainline function signature.

    push_output(ctx, &ctx->mainline_intro);

    output_line(ctx, "%s%s %s(%s%s%s)",

                ctx->outputs ? ctx->mainfn : "void",

                ctx->outputs ? "_Output" : "",

                ctx->mainfn,

                ctx->inputs ? ctx->mainfn : "",