/**

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

#include <math.h>

{

    // 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 = (double *) alloca(sizeof (double) * preshader->temp_count);

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

    double dst[4];

    double src[3][4];

    const double *src0 = src[0];

    const double *src1 = src[1];

    const double *src2 = src[2];

    MOJOSHADER_preshaderInstruction *inst = preshader->instructions;

    int instit;

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

    {

        const MOJOSHADER_preshaderOperand *operand = inst->operands;

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

        const int elems = inst->element_count;

        const int elemsbytes = sizeof (double) * elems;

        // load up our operands...

        int opiter, elemiter;

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

        {

            const unsigned int index = operand->index;

            switch (operand->type)

            {

                case MOJOSHADER_PRESHADEROPERAND_LITERAL:

                {

                    const double *lit = &preshader->literals[index];

                    if (!isscalar)

                        memcpy(src[opiter], lit, elemsbytes);

                    else

                    {

                        const double val = *lit;

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

                            src[opiter][elemiter] = val;

                    } // else

                    break;

                } // case

                case MOJOSHADER_PRESHADEROPERAND_INPUT:

                case MOJOSHADER_PRESHADEROPERAND_OUTPUT:

                    if (isscalar)

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

                    else

                    {

                        int cpy;

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

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

                    } // else

                    break;

                case MOJOSHADER_PRESHADEROPERAND_TEMP:

                    if (isscalar)

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

                    else

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

                    break;

                default:

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

                    break;

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

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

            } // case

            #define OPCODE_CASE_SCALAR(op, val) \

                case MOJOSHADER_PRESHADEROP_##op##_SCALAR: { \

                    const double final = val; \

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

                    break; \

                }

            OPCODE_CASE_SCALAR(MIN, (src0[0] < src1[0]) ? src0[0] : src1[0])

            OPCODE_CASE_SCALAR(MAX, (src0[0] > src1[0]) ? src0[0] : src1[0])

            OPCODE_CASE_SCALAR(LT, (src0[0] < src1[0]) ? 1.0 : 0.0)

            OPCODE_CASE_SCALAR(GE, (src0[0] >= src1[0]) ? 1.0 : 0.0)

            OPCODE_CASE_SCALAR(ADD, src0[0] + src1[0])

            OPCODE_CASE_SCALAR(MUL, src0[0] * src1[0])

            OPCODE_CASE_SCALAR(ATAN2, atan2(src0[0], src1[0]))

            OPCODE_CASE_SCALAR(DIV, src0[0] / src1[0])

            //OPCODE_CASE_SCALAR(DOT)  // !!! FIXME: isn't this just a MUL?

            //OPCODE_CASE_SCALAR(NOISE, ???)  // !!! FIXME: ?

            #undef OPCODE_CASE_SCALAR

            default:

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

                break;

        } // switch

        // Figure out where dst wants to be stored.

        operand = inst->operands;

        if (operand->type == MOJOSHADER_PRESHADEROPERAND_TEMP)

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

        else

        {

            assert(operand->type == MOJOSHADER_PRESHADEROPERAND_OUTPUT);

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

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

        } // else

    } // for

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

// !!! FIXME: this is sort of a big, ugly function.

const MOJOSHADER_effect *MOJOSHADER_parseEffect(const char *profile,

                                                const unsigned char *buf,

                                                const unsigned int _len,

                                                const MOJOSHADER_swizzle *swiz,

                                                const unsigned int swizcount,

                                                MOJOSHADER_malloc m,

                                                MOJOSHADER_free f,

                                                void *d)

{

    if ( ((m == NULL) && (f != NULL)) || ((m != NULL) && (f == NULL)) )

        return &MOJOSHADER_out_of_mem_effect;  // supply both or neither.

    if (m == NULL) m = MOJOSHADER_internal_malloc;

    if (f == NULL) f = MOJOSHADER_internal_free;

    MOJOSHADER_effect *retval = m(sizeof (MOJOSHADER_effect), d);

    if (retval == NULL)

        return &MOJOSHADER_out_of_mem_effect;  // supply both or neither.

    memset(retval, '\0', sizeof (*retval));

    retval->malloc = m;

    retval->free = f;

    retval->malloc_data = d;

    const uint8 *ptr = (const uint8 *) buf;

    uint32 len = (uint32) _len;

    size_t siz = 0;

    int i, j, k;

    if (len < 8)

        goto parseEffect_unexpectedEOF;

    const uint8 *base = NULL;

    if (readui32(&ptr, &len) != 0xFEFF0901) // !!! FIXME: is this always magic?

        goto parseEffect_notAnEffectsFile;

    else

    {

        const uint32 offset = readui32(&ptr, &len);

        base = ptr;

//printf("base offset == %u\n", offset);

        if (offset > len)

            goto parseEffect_unexpectedEOF;

        ptr += offset;

        len -= offset;

    } // else

    // params...

    if (len < 16)

        goto parseEffect_unexpectedEOF;

    const uint32 numparams = readui32(&ptr, &len);

    const uint32 numtechniques = readui32(&ptr, &len);

    readui32(&ptr, &len); // !!! FIXME: there are 8 unknown bytes here. Annotations?

    /*const uint32 numobjects = */ readui32(&ptr, &len);

    if (numparams > 0)

    {

        siz = sizeof (MOJOSHADER_effectParam) * numparams;

        retval->params = (MOJOSHADER_effectParam *) m(siz, d);

        if (retval->params == NULL)

            goto parseEffect_outOfMemory;

        memset(retval->params, '\0', siz);

        retval->param_count = numparams;

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

        {

            if (len < 16)

                goto parseEffect_unexpectedEOF;

            const uint32 typeoffset = readui32(&ptr, &len);

            const uint32 valoffset = readui32(&ptr, &len);

            const uint32 flags = readui32(&ptr, &len);

            const uint32 numannos = readui32(&ptr, &len);

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

            {

                if (len < 8)

                    goto parseEffect_unexpectedEOF;

                // !!! FIXME: parse annotations.

                readui32(&ptr, &len);

                readui32(&ptr, &len);

            } // for

            const uint8 *typeptr = base + typeoffset;

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

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

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

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

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

            // !!! FIXME: sanity checks!

            const char *namestr = ((const char *) base) + paramname;

            const char *semstr = ((const char *) base) + paramsemantic;

            uint32 len;

            char *strptr;

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

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

            memcpy(strptr, namestr + 4, len);

            strptr[len] = '\0';

            retval->params[i].name = strptr;

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

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

            memcpy(strptr, semstr + 4, len);

            strptr[len] = '\0';

            retval->params[i].semantic = strptr;

        } // for

    } // if

    uint32 numshaders = 0;  // we'll calculate this later.

    // techniques...

    if (numtechniques > 0)

    {

        siz = sizeof (MOJOSHADER_effectTechnique) * numtechniques;

        retval->techniques = (MOJOSHADER_effectTechnique *) m(siz, d);

        if (retval->techniques == NULL)

            goto parseEffect_outOfMemory;

        memset(retval->techniques, '\0', siz);

        retval->technique_count = numtechniques;

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

        {

            if (len < 12)

                goto parseEffect_unexpectedEOF;

            MOJOSHADER_effectTechnique *technique = &retval->techniques[i];

            const uint32 nameoffset = readui32(&ptr, &len);

            const uint32 numannos = readui32(&ptr, &len);

            const uint32 numpasses = readui32(&ptr, &len);

            if (nameoffset >= _len)

                goto parseEffect_unexpectedEOF;

            if (numannos > 0)

            {

                // !!! FIXME: expose these to the caller?

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

                {

                    if (len < 8)

                        goto parseEffect_unexpectedEOF;

                    readui32(&ptr, &len);  // typedef offset

                    readui32(&ptr, &len);  // value offset

                } // for

            } // if

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

            {

                const char *namestr = ((char *) base) + nameoffset;

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

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

                memcpy(strptr, namestr + 4, len);

                strptr[len] = '\0';

                technique->name = strptr;

            }

            if (numpasses > 0)

            {

                technique->pass_count = numpasses;

                siz = sizeof (MOJOSHADER_effectPass) * numpasses;

                technique->passes = (MOJOSHADER_effectPass *) m(siz, d);

                if (technique->passes == NULL)

                    goto parseEffect_outOfMemory;

                memset(technique->passes, '\0', siz);

                for (j = 0; j < numpasses; j++)

                {

                    if (len < 12)

                        goto parseEffect_unexpectedEOF;

                    MOJOSHADER_effectPass *pass = &technique->passes[j];

                    const uint32 passnameoffset = readui32(&ptr, &len);

                    const uint32 numannos = readui32(&ptr, &len);

                    const uint32 numstates = readui32(&ptr, &len);

                    if (passnameoffset >= _len)

                        goto parseEffect_unexpectedEOF;

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

                    {

                        const char *namestr = ((char *) base) + passnameoffset;

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

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

                        memcpy(strptr, namestr + 4, len);

                        strptr[len] = '\0';

                        pass->name = strptr;

                    }

                    if (numannos > 0)

                    {

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

                        {

                            if (len < 8)

                                goto parseEffect_unexpectedEOF;

                            // !!! FIXME: do something with this.

                            readui32(&ptr, &len);

                            readui32(&ptr, &len);

                        } // for

                    } // if

                    if (numstates > 0)

                    {

                        pass->state_count = numstates;

                        siz = sizeof (MOJOSHADER_effectState) * numstates;

                        pass->states = (MOJOSHADER_effectState *) m(siz, d);

                        if (pass->states == NULL)

                            goto parseEffect_outOfMemory;

                        memset(pass->states, '\0', siz);

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

                        {

                            if (len < 16)

                                goto parseEffect_unexpectedEOF;

                            MOJOSHADER_effectState *state = &pass->states[k];

                            const uint32 type = readui32(&ptr, &len);

                            readui32(&ptr, &len);  // !!! FIXME: don't know what this field does.

                            /*const uint32 offsetend = */ readui32(&ptr, &len);

                            /*const uint32 offsetstart = */ readui32(&ptr, &len);

                            state->type = type;

                            if ((type == 0x92) || (type == 0x93))

                                numshaders++;

                        } // for

                    } // if

                } // for

            } // if

        } // for

    } // if

    // textures...

    if (len < 8)

        goto parseEffect_unexpectedEOF;

    const int numtextures = readui32(&ptr, &len);

    const int numobjects = readui32(&ptr, &len);  // !!! FIXME: "objects" for lack of a better word.

    if (numtextures > 0)

    {

        siz = sizeof (MOJOSHADER_effectTexture) * numtextures;

        retval->textures = m(siz, d);

        if (retval->textures == NULL)

            goto parseEffect_outOfMemory;

        memset(retval->textures, '\0', siz);

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

        {

            if (len < 8)

                goto parseEffect_unexpectedEOF;

            MOJOSHADER_effectTexture *texture = &retval->textures[i];

            const uint32 texparam = readui32(&ptr, &len);

            const uint32 texsize = readui32(&ptr, &len);

            // apparently texsize will pad out to 32 bits.

            const uint32 readsize = (((texsize + 3) / 4) * 4);

            if (len < readsize)

                goto parseEffect_unexpectedEOF;

            texture->param = texparam;

            char *str = m(texsize + 1, d);

            if (str == NULL)

                goto parseEffect_outOfMemory;

            memcpy(str, ptr, texsize);

            str[texsize] = '\0';

            texture->name = str;

            ptr += readsize;

            len -= readsize;

        } // for

    } // if

    // shaders...

    if (numshaders > 0)

    {

        siz = sizeof (MOJOSHADER_effectShader) * numshaders;

        retval->shaders = (MOJOSHADER_effectShader *) m(siz, d);

        if (retval->shaders == NULL)

            goto parseEffect_outOfMemory;

        memset(retval->shaders, '\0', siz);

        retval->shader_count = numshaders;

        // !!! FIXME: I wonder if we should pull these from offsets and not

        // !!! FIXME:  count on them all being in a line like this.

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

        {

            if (len < 24)

                goto parseEffect_unexpectedEOF;

            MOJOSHADER_effectShader *shader = &retval->shaders[i];

            const uint32 technique = readui32(&ptr, &len);

            const uint32 pass = readui32(&ptr, &len);

            readui32(&ptr, &len);  // !!! FIXME: don't know what this does.

            readui32(&ptr, &len);  // !!! FIXME: don't know what this does (vertex/pixel/geometry?)

            readui32(&ptr, &len);  // !!! FIXME: don't know what this does.

            const uint32 shadersize = readui32(&ptr, &len);

            if (len < shadersize)

                goto parseEffect_unexpectedEOF;

            shader->technique = technique;

            shader->pass = pass;

            shader->shader = MOJOSHADER_parse(profile, ptr, shadersize,

                                              swiz, swizcount, m, f, d);

            // !!! FIXME: check for errors.

            ptr += shadersize;

            len -= shadersize;

        } // for

    } // if