/**

 * 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_internal.h"

#ifdef MOJOSHADER_EFFECT_SUPPORT

#ifndef MOJOSHADER_USE_SDL_STDLIB

#include <math.h>

#endif /* MOJOSHADER_USE_SDL_STDLIB */

void MOJOSHADER_runPreshader(const MOJOSHADER_preshader *preshader,

                             float *outregs)

{

    const float *inregs = preshader->registers;

    // this is fairly straightforward, as there aren't any branching

    //  opcodes in the preshader instruction set (at the moment, at least).

    const int scalarstart = (int) MOJOSHADER_PRESHADEROP_SCALAR_OPS;

    double *temps = NULL;

    if (preshader->temp_count > 0)

    {

        temps = (double *) alloca(sizeof (double) * preshader->temp_count);

        memset(temps, '\0', sizeof (double) * preshader->temp_count);

    } // if

    double dst[4] = { 0, 0, 0, 0 };

    double src[3][4] = { { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } };

    const double *src0 = &src[0][0];

    const double *src1 = &src[1][0];

    const double *src2 = &src[2][0];

    MOJOSHADER_preshaderInstruction *inst = preshader->instructions;

    int instit;

#if 0 // FIXME: Do we need to do this or is the compiler smart enough?

    // Clear preshader output registers first!

    for (instit = 0; instit < preshader->instruction_count; instit++, inst++)

    {

        const MOJOSHADER_preshaderOperand *operand = &inst->operands[inst->operand_count - 1];

        if (operand->type == MOJOSHADER_PRESHADEROPERAND_OUTPUT)

            memset(&outregs[operand->index], '\0', sizeof(float) * 4);

    } // for

    inst = preshader->instructions;

#endif

    for (instit = 0; instit < preshader->instruction_count; instit++, inst++)

    {

        const MOJOSHADER_preshaderOperand *operand = inst->operands;

        const int elems = inst->element_count;

        const int elemsbytes = sizeof (double) * elems;

        const int isscalarop = (inst->opcode >= scalarstart);

        assert(elems >= 0);

        assert(elems <= 4);

        // load up our operands...

        int opiter, elemiter;

        for (opiter = 0; opiter < inst->operand_count-1; opiter++, operand++)

        {

            const int isscalar = ((isscalarop) && (opiter == 0));

            const unsigned int index = operand->index;

            switch (operand->type)

            {

                case MOJOSHADER_PRESHADEROPERAND_LITERAL:

                {

                    if (!isscalar)

                    {

                        assert((index + elems) <= preshader->literal_count);

                        memcpy(&src[opiter][0], &preshader->literals[index], elemsbytes);

                    } // if

                    else

                    {

                        for (elemiter = 0; elemiter < elems; elemiter++)

                            src[opiter][elemiter] = preshader->literals[index];

                    } // else

                    break;

                } // case

                case MOJOSHADER_PRESHADEROPERAND_INPUT:

                    if (operand->array_register_count > 0)

                    {

                        int i;

                        const int *regsi = (const int *) inregs;

                        int arrIndex = regsi[((index >> 4) * 4) + ((index >> 2) & 3)];

                        for (i = 0; i < operand->array_register_count; i++)

                        {

                            arrIndex = regsi[operand->array_registers[i] + arrIndex];

                        }

                        src[opiter][0] = arrIndex;

                    } // if

                    else if (isscalar)

                        src[opiter][0] = inregs[index];

                    else

                    {

                        int cpy;

                        for (cpy = 0; cpy < elems; cpy++)

                            src[opiter][cpy] = inregs[index+cpy];

                    } // else

                    break;

                case MOJOSHADER_PRESHADEROPERAND_OUTPUT:

                    if (isscalar)

                        src[opiter][0] = outregs[index];

                    else

                    {

                        int cpy;

                        for (cpy = 0; cpy < elems; cpy++)

                            src[opiter][cpy] = outregs[index+cpy];

                    } // else

                    break;

                case MOJOSHADER_PRESHADEROPERAND_TEMP:

                    if (temps != NULL)

                    {

                        if (isscalar)

                            src[opiter][0] = temps[index];

                        else

                            memcpy(src[opiter], temps + index, elemsbytes);

                    } // if

                    break;

                default:

                    assert(0 && "unexpected preshader operand type.");

                    return;

            } // switch

        } // for

        // run the actual instruction, store result to dst.

        int i;

        switch (inst->opcode)

        {

            #define OPCODE_CASE(op, val) \

                case MOJOSHADER_PRESHADEROP_##op: \

                    for (i = 0; i < elems; i++) { dst[i] = val; } \

                    break;

            //OPCODE_CASE(NOP, 0.0)  // not a real instruction.

            OPCODE_CASE(MOV, src0[i])

            OPCODE_CASE(NEG, -src0[i])

            OPCODE_CASE(RCP, 1.0 / src0[i])

            OPCODE_CASE(FRC, src0[i] - floor(src0[i]))

            OPCODE_CASE(EXP, exp(src0[i]))

            OPCODE_CASE(LOG, log(src0[i]))

            OPCODE_CASE(RSQ, 1.0 / sqrt(src0[i]))

            OPCODE_CASE(SIN, sin(src0[i]))

            OPCODE_CASE(COS, cos(src0[i]))

            OPCODE_CASE(ASIN, asin(src0[i]))

            OPCODE_CASE(ACOS, acos(src0[i]))

            OPCODE_CASE(ATAN, atan(src0[i]))

            OPCODE_CASE(MIN, (src0[i] < src1[i]) ? src0[i] : src1[i])

            OPCODE_CASE(MAX, (src0[i] > src1[i]) ? src0[i] : src1[i])

            OPCODE_CASE(LT, (src0[i] < src1[i]) ? 1.0 : 0.0)

            OPCODE_CASE(GE, (src0[i] >= src1[i]) ? 1.0 : 0.0)

            OPCODE_CASE(ADD, src0[i] + src1[i])

            OPCODE_CASE(MUL,  src0[i] * src1[i])

            OPCODE_CASE(ATAN2, atan2(src0[i], src1[i]))

            OPCODE_CASE(DIV, src0[i] / src1[i])

            OPCODE_CASE(CMP, (src0[i] >= 0.0) ? src1[i] : src2[i])

            //OPCODE_CASE(NOISE, ???)  // !!! FIXME: don't know what this does

            //OPCODE_CASE(MOVC, ???)  // !!! FIXME: don't know what this does

            OPCODE_CASE(MIN_SCALAR, (src0[0] < src1[i]) ? src0[0] : src1[i])

            OPCODE_CASE(MAX_SCALAR, (src0[0] > src1[i]) ? src0[0] : src1[i])

            OPCODE_CASE(LT_SCALAR, (src0[0] < src1[i]) ? 1.0 : 0.0)

            OPCODE_CASE(GE_SCALAR, (src0[0] >= src1[i]) ? 1.0 : 0.0)

            OPCODE_CASE(ADD_SCALAR, src0[0] + src1[i])

            OPCODE_CASE(MUL_SCALAR, src0[0] * src1[i])

            OPCODE_CASE(ATAN2_SCALAR, atan2(src0[0], src1[i]))

            OPCODE_CASE(DIV_SCALAR, src0[0] / src1[i])

            //OPCODE_CASE(DOT_SCALAR)  // !!! FIXME: isn't this just a MUL?

            //OPCODE_CASE(NOISE_SCALAR, ???)  // !!! FIXME: ?

            #undef OPCODE_CASE

            case MOJOSHADER_PRESHADEROP_DOT:

            {

                double final = 0.0;

                for (i = 0; i < elems; i++)

                    final += src0[i] * src1[i];

                for (i = 0; i < elems; i++)

                    dst[i] = final;  // !!! FIXME: is this right?

                break;

            } // case

            default:

                assert(0 && "Unhandled preshader opcode!");

                break;

        } // switch

        // Figure out where dst wants to be stored.

        if (operand->type == MOJOSHADER_PRESHADEROPERAND_TEMP)

        {

            assert(preshader->temp_count >=

                    operand->index + (elemsbytes / sizeof (double)));

            memcpy(temps + operand->index, dst, elemsbytes);

        } // if

        else

        {

            assert(operand->type == MOJOSHADER_PRESHADEROPERAND_OUTPUT);

            for (i = 0; i < elems; i++)

                outregs[operand->index + i] = (float) dst[i];

        } // else

    } // for

} // MOJOSHADER_runPreshader

static MOJOSHADER_effect MOJOSHADER_out_of_mem_effect = {

    1, &MOJOSHADER_out_of_mem_error, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

};

static MOJOSHADER_error MOJOSHADER_need_a_backend_error = {

    "Need a MOJOSHADER_effectShaderContext", NULL, MOJOSHADER_POSITION_NONE

};

static MOJOSHADER_effect MOJOSHADER_need_a_backend_effect = {

    1, &MOJOSHADER_need_a_backend_error, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

};

static MOJOSHADER_error MOJOSHADER_unexpected_eof_error = {

    "Unexpected EOF", NULL, MOJOSHADER_POSITION_NONE

};

static MOJOSHADER_effect MOJOSHADER_unexpected_eof_effect = {

    1, &MOJOSHADER_unexpected_eof_error, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

};

static MOJOSHADER_error MOJOSHADER_not_an_effect_error = {

    "Not an Effects Framework binary", NULL, MOJOSHADER_POSITION_NONE

};

static MOJOSHADER_effect MOJOSHADER_not_an_effect_effect = {

    1, &MOJOSHADER_not_an_effect_error, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

};

static void push_errors(ErrorList *list, MOJOSHADER_error *errors, int len)

{

    int i;

    for (i = 0; i < len; i += 1)

        errorlist_add(list, errors[i].filename, errors[i].error_position, errors[i].error);

} // push_errors

static uint32 readui32(const uint8 **_ptr, uint32 *_len)

{

    uint32 retval = 0;

    if (*_len < sizeof (retval))

        *_len = 0;

    else

    {

        const uint32 *ptr = (const uint32 *) *_ptr;

        retval = SWAP32(*ptr);

        *_ptr += sizeof (retval);

        *_len -= sizeof (retval);

    } // else

    return retval;

} // readui32

static char *readstring(const uint8 *base,

                        const uint32 offset,

                        MOJOSHADER_malloc m,

                        void *d)

{

    // !!! FIXME: sanity checks!

    // !!! FIXME: verify this doesn't go past EOF looking for a null.

    const char *str = ((const char *) base) + offset;

    const uint32 len = *((const uint32 *) str);

    char *strptr = NULL;

    if (len == 0) return NULL; /* No length? No string. */

    strptr = (char *) m(len, d);

    memcpy(strptr, str + 4, len);

    return strptr;

} // readstring

static int findparameter(const MOJOSHADER_effectParam *params,

                         const uint32 param_count,

                         const char *name)

{

    int i;

    for (i = 0; i < param_count; i++)

        if (strcmp(name, params[i].value.name) == 0)

            return i;

    assert(0 && "Parameter not found!");

    return -1;

}

static void readvalue(const uint8 *base,

                      const uint32 typeoffset,

                      const uint32 valoffset,

                      MOJOSHADER_effectValue *value,

                      MOJOSHADER_effectObject *objects,

                      MOJOSHADER_malloc m,

                      void *d)

{

    int i, j, k;

    const uint8 *typeptr = base + typeoffset;

    const uint8 *valptr = base + valoffset;

    unsigned int typelen = 9999999;  // !!! FIXME

    const uint32 type = readui32(&typeptr, &typelen);

    const uint32 valclass = readui32(&typeptr, &typelen);

    const uint32 name = readui32(&typeptr, &typelen);

    const uint32 semantic = readui32(&typeptr, &typelen);

    const uint32 numelements = readui32(&typeptr, &typelen);

    value->type.parameter_type = (MOJOSHADER_symbolType) type;

    value->type.parameter_class = (MOJOSHADER_symbolClass) valclass;

    value->name = readstring(base, name, m, d);

    value->semantic = readstring(base, semantic, m, d);

    value->type.elements = numelements;

    /* Class sanity check */

    assert(valclass >= MOJOSHADER_SYMCLASS_SCALAR && valclass <= MOJOSHADER_SYMCLASS_STRUCT);

    if (valclass == MOJOSHADER_SYMCLASS_SCALAR

     || valclass == MOJOSHADER_SYMCLASS_VECTOR

     || valclass == MOJOSHADER_SYMCLASS_MATRIX_ROWS

     || valclass == MOJOSHADER_SYMCLASS_MATRIX_COLUMNS)

    {

        /* These classes only ever contain scalar values */

        assert(type >= MOJOSHADER_SYMTYPE_BOOL && type <= MOJOSHADER_SYMTYPE_FLOAT);

        const uint32 columncount = readui32(&typeptr, &typelen);

        const uint32 rowcount = readui32(&typeptr, &typelen);

        value->type.columns = columncount;

        value->type.rows = rowcount;

        uint32 siz = 4 * rowcount;

        if (numelements > 0)

            siz *= numelements;

        value->value_count = siz;

        siz *= 4;

        value->values = m(siz, d);

        memset(value->values, '\0', siz);

        siz /= 16;

        for (i = 0; i < siz; i++)

            memcpy(value->valuesF + (i << 2), valptr + ((columncount << 2) * i), columncount << 2);

    } // if

    else if (valclass == MOJOSHADER_SYMCLASS_OBJECT)

    {

        /* This class contains either samplers or "objects" */

        assert(type >= MOJOSHADER_SYMTYPE_STRING && type <= MOJOSHADER_SYMTYPE_VERTEXSHADER);

        if (type == MOJOSHADER_SYMTYPE_SAMPLER

         || type == MOJOSHADER_SYMTYPE_SAMPLER1D

         || type == MOJOSHADER_SYMTYPE_SAMPLER2D

         || type == MOJOSHADER_SYMTYPE_SAMPLER3D

         || type == MOJOSHADER_SYMTYPE_SAMPLERCUBE)

        {

            unsigned int vallen = 9999999; // !!! FIXME

            const uint32 numstates = readui32(&valptr, &vallen);

            value->value_count = numstates;

            const uint32 siz = sizeof(MOJOSHADER_effectSamplerState) * numstates;

            value->values = m(siz, d);

            memset(value->values, '\0', siz);

            for (i = 0; i < numstates; i++)

            {

                MOJOSHADER_effectSamplerState *state = &value->valuesSS[i];

                const uint32 stype = readui32(&valptr, &vallen) & ~0xA0;

                /*const uint32 FIXME =*/ readui32(&valptr, &vallen);

                const uint32 statetypeoffset = readui32(&valptr, &vallen);

                const uint32 statevaloffset = readui32(&valptr, &vallen);

                state->type = (MOJOSHADER_samplerStateType) stype;

                readvalue(base, statetypeoffset, statevaloffset,

                          &state->value, objects,

                          m, d);

                if (stype == MOJOSHADER_SAMP_TEXTURE)

                    objects[state->value.valuesI[0]].type = (MOJOSHADER_symbolType) type;

            } // for

        } // if

        else

        {

            uint32 numobjects = 1;

            if (numelements > 0)

                numobjects = numelements;

            value->value_count = numobjects;

            const uint32 siz = 4 * numobjects;

            value->values = m(siz, d);

            memcpy(value->values, valptr, siz);

            for (i = 0; i < value->value_count; i++)

                objects[value->valuesI[i]].type = (MOJOSHADER_symbolType) type;

        } // else

    } // else if

    else if (valclass == MOJOSHADER_SYMCLASS_STRUCT)

    {

        uint32 siz;

        value->type.member_count = readui32(&typeptr, &typelen);

        siz = value->type.member_count * sizeof (MOJOSHADER_symbolStructMember);

        value->type.members = (MOJOSHADER_symbolStructMember *) m(siz, d);

        uint32 structsize = 0;

        for (i = 0; i < value->type.member_count; i++)

        {

            MOJOSHADER_symbolStructMember *mem = &value->type.members[i];

            mem->info.parameter_type = (MOJOSHADER_symbolType) readui32(&typeptr, &typelen);

            mem->info.parameter_class = (MOJOSHADER_symbolClass) readui32(&typeptr, &typelen);

            const uint32 memname = readui32(&typeptr, &typelen);

            /*const uint32 memsemantic =*/ readui32(&typeptr, &typelen);

            mem->name = readstring(base, memname, m, d);

            mem->info.elements = readui32(&typeptr, &typelen);

            mem->info.columns = readui32(&typeptr, &typelen);

            mem->info.rows = readui32(&typeptr, &typelen);

            // !!! FIXME: Nested structs! -flibit

            assert(mem->info.parameter_class >= MOJOSHADER_SYMCLASS_SCALAR

                && mem->info.parameter_class <= MOJOSHADER_SYMCLASS_MATRIX_COLUMNS);

            assert(mem->info.parameter_type >= MOJOSHADER_SYMTYPE_BOOL

                && mem->info.parameter_type <= MOJOSHADER_SYMTYPE_FLOAT);

            mem->info.member_count = 0;

            mem->info.members = NULL;

            uint32 memsize = 4 * mem->info.rows;

            if (mem->info.elements > 0)

                memsize *= mem->info.elements;

            structsize += memsize;

        } // for

        value->type.columns = structsize;

        value->type.rows = 1;

        value->value_count = structsize;

        if (numelements > 0)

            value->value_count *= numelements;

        siz = value->value_count * 4;

        value->values = m(siz, d);

        memset(value->values, '\0', siz);

        int dst_offset = 0, src_offset = 0;

        i = 0;

        do

        {

            for (j = 0; j < value->type.member_count; j++)

            {

                siz = value->type.members[j].info.rows * value->type.members[j].info.elements;

                for (k = 0; k < siz; k++)

                {

                    memcpy(value->valuesF + dst_offset,

                           typeptr + src_offset, /* Yes, typeptr. -flibit */

                           value->type.members[j].info.columns << 2);

                    dst_offset += 4;

                    src_offset += value->type.members[j].info.columns << 2;

                } // for

            }

        } while (++i < numelements);

    } // else if

} // readvalue

static void readannotations(const uint32 numannos,

                            const uint8 *base,

                            const uint8 **ptr,

                            uint32 *len,

                            MOJOSHADER_effectAnnotation **annotations,

                            MOJOSHADER_effectObject *objects,

                            MOJOSHADER_malloc m,

                            void *d)

{

    int i;

    if (numannos == 0) return;

    const uint32 siz = sizeof(MOJOSHADER_effectAnnotation) * numannos;

    *annotations = (MOJOSHADER_effectAnnotation *) m(siz, d);

    memset(*annotations, '\0', siz);

    for (i = 0; i < numannos; i++)

    {

        MOJOSHADER_effectAnnotation *anno = &(*annotations)[i];

        const uint32 typeoffset = readui32(ptr, len);

        const uint32 valoffset = readui32(ptr, len);

        readvalue(base, typeoffset, valoffset,

                  anno, objects,

                  m, d);

    } // for

} // readannotation

static void readparameters(const uint32 numparams,

                           const uint8 *base,

                           const uint8 **ptr,

                           uint32 *len,

                           MOJOSHADER_effectParam **params,

                           MOJOSHADER_effectObject *objects,

                           MOJOSHADER_malloc m,

                           void *d)

{