/**

* 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

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 int elems = inst->element_count;

const int elemsbytes = sizeof (double) * elems;

assert(elems >= 0);

assert(elems <= 4);

// load up our operands...

int opiter, elemiter;

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

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

else

{

int cpy;

for (cpy = 0; cpy < elems; 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.");

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

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

else

{

assert(operand->type == MOJOSHADER_PRESHADEROPERAND_OUTPUT);

for (i = 0; i < elems; 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 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!");

}

static void readvalue(const uint8 *base,

const uint32 typeoffset,

const uint32 valoffset,

MOJOSHADER_effectValue *value,

MOJOSHADER_effectObject *objects,

MOJOSHADER_malloc m,

void *d)

{

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

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

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

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;

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

assert(mem->info.parameter_type >= MOJOSHADER_SYMTYPE_BOOL

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

mem->info.member_count = 0;

mem->info.members = NULL;

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)

{

int i;

if (numparams == 0) return;

uint32 siz = sizeof(MOJOSHADER_effectParam) * numparams;

*params = (MOJOSHADER_effectParam *) m(siz, d);

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

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

const uint32 typeoffset = readui32(ptr, len);

const uint32 valoffset = readui32(ptr, len);

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

const uint32 numannos = readui32(ptr, len);

param->annotation_count = numannos;

readannotations(numannos, base, ptr, len,

&param->annotations, objects,

m, d);

readvalue(base, typeoffset, valoffset,

&param->value, objects,

m, d);

} // for

} // readparameters

static void readstates(const uint32 numstates,

const uint8 *base,

const uint8 **ptr,

uint32 *len,

MOJOSHADER_effectState **states,

MOJOSHADER_effectObject *objects,

MOJOSHADER_malloc m,

void *d)

{

int i;

if (numstates == 0) return;

const uint32 siz = sizeof (MOJOSHADER_effectState) * numstates;

*states = (MOJOSHADER_effectState *) m(siz, d);

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

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

{

MOJOSHADER_effectState *state = &(*states)[i];

const uint32 type = readui32(ptr, len);

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

const uint32 typeoffset = readui32(ptr, len);

const uint32 valoffset = readui32(ptr, len);

state->type = (MOJOSHADER_renderStateType) type;

readvalue(base, typeoffset, valoffset,

&state->value, objects,

m, d);

} // for

} // readstates

static void readpasses(const uint32 numpasses,

const uint8 *base,

const uint8 **ptr,

uint32 *len,

MOJOSHADER_effectPass **passes,

MOJOSHADER_effectObject *objects,

MOJOSHADER_malloc m,

void *d)

{

int i;

if (numpasses == 0) return;

const uint32 siz = sizeof (MOJOSHADER_effectPass) * numpasses;

*passes = (MOJOSHADER_effectPass *) m(siz, d);

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

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

const uint32 passnameoffset = readui32(ptr, len);

const uint32 numannos = readui32(ptr, len);

const uint32 numstates = readui32(ptr, len);

pass->annotation_count = numannos;

readannotations(numannos, base, ptr, len,

&pass->annotations, objects,

m, d);

pass->state_count = numstates;

readstates(numstates, base, ptr, len,

&pass->states, objects,

m, d);

} // for

} // readpasses

static void readtechniques(const uint32 numtechniques,

const uint8 *base,

const uint8 **ptr,

uint32 *len,

MOJOSHADER_effectTechnique **techniques,

MOJOSHADER_effectObject *objects,

MOJOSHADER_malloc m,

void *d)

{

int i;

if (numtechniques == 0) return;

const uint32 siz = sizeof (MOJOSHADER_effectTechnique) * numtechniques;

*techniques = (MOJOSHADER_effectTechnique *) m(siz, d);

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

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

{

MOJOSHADER_effectTechnique *technique = &(*techniques)[i];

const uint32 nameoffset = readui32(ptr, len);

const uint32 numannos = readui32(ptr, len);

const uint32 numpasses = readui32(ptr, len);

technique->annotation_count = numannos;

readannotations(numannos, base, ptr, len,

&technique->annotations, objects,

m, d);

technique->pass_count = numpasses;

readpasses(numpasses, base, ptr, len,

&technique->passes, objects,

m, d);

} // for

} // readtechniques

static void readsmallobjects(const uint32 numsmallobjects,

const uint8 **ptr,

uint32 *len,

MOJOSHADER_effect *effect,

const MOJOSHADER_swizzle *swiz,

const unsigned int swizcount,

const MOJOSHADER_samplerMap *smap,

const unsigned int smapcount,

ErrorList *errors)

{

int i, j;

MOJOSHADER_parseData *pd;

MOJOSHADER_malloc m = effect->ctx.m;

void *d = effect->ctx.malloc_data;

for (i = 1; i < numsmallobjects + 1; i++)

{

const uint32 index = readui32(ptr, len);

const uint32 length = readui32(ptr, len);

MOJOSHADER_effectObject *object = &effect->objects[index];

if (object->type == MOJOSHADER_SYMTYPE_STRING)

{

if (length > 0)

{

char *str = (char *) m(length, d);

memcpy(str, *ptr, length);

object->string.string = str;

} // if

} // if

else if (object->type == MOJOSHADER_SYMTYPE_TEXTURE

|| object->type == MOJOSHADER_SYMTYPE_TEXTURE1D

|| object->type == MOJOSHADER_SYMTYPE_TEXTURE2D

|| object->type == MOJOSHADER_SYMTYPE_TEXTURE3D

|| object->type == MOJOSHADER_SYMTYPE_TEXTURECUBE

|| object->type == MOJOSHADER_SYMTYPE_SAMPLER

|| object->type == MOJOSHADER_SYMTYPE_SAMPLER1D

|| object->type == MOJOSHADER_SYMTYPE_SAMPLER2D

|| object->type == MOJOSHADER_SYMTYPE_SAMPLER3D

|| object->type == MOJOSHADER_SYMTYPE_SAMPLERCUBE)

{

if (length > 0)

{

char *str = (char *) m(length, d);

memcpy(str, *ptr, length);

object->mapping.name = str;

} // if

} // else if

else if (object->type == MOJOSHADER_SYMTYPE_PIXELSHADER

|| object->type == MOJOSHADER_SYMTYPE_VERTEXSHADER)

{

object->shader.technique = -1;

object->shader.pass = -1;

object->shader.shader = effect->ctx.compileShader(mainfn, *ptr, length,

swiz, swizcount,

smap, smapcount);

if (object->shader.shader == NULL)

{

// Bail ASAP, so we can get the error to the application

errorlist_add(errors, NULL, 0, effect->ctx.getError());

return;

} // if

if (pd->error_count > 0)

{

// Bail ASAP, so we can get the error to the application

push_errors(errors, pd->errors, pd->error_count);

return;

} // if

for (j = 0; j < pd->symbol_count; j++)

if (pd->symbols[j].register_set == MOJOSHADER_SYMREGSET_SAMPLER)

object->shader.params = (uint32 *) m(object->shader.param_count * sizeof (uint32), d);

object->shader.samplers = (MOJOSHADER_samplerStateRegister *) m(object->shader.sampler_count * sizeof (MOJOSHADER_samplerStateRegister), d);

uint32 curSampler = 0;

{

int par = findparameter(effect->params,

effect->param_count,

object->shader.samplers[curSampler].sampler_state_count = effect->params[par].value.value_count;

object->shader.samplers[curSampler].sampler_states = effect->params[par].value.valuesSS;

curSampler++;

} // if

} // for

{

object->shader.preshader_params[j] = findparameter(effect->params,

effect->param_count,

} // for

} // if

} // else if

else

{

assert(0 && "Small object type unknown!");

} // else

/* Object block is always a multiple of four */

const uint32 blocklen = (length + 3) - ((length - 1) % 4);

*ptr += blocklen;

*len -= blocklen;

} // for

} // readstrings

static void readlargeobjects(const uint32 numlargeobjects,

const uint32 numsmallobjects,

const uint8 **ptr,

uint32 *len,

MOJOSHADER_effect *effect,

const MOJOSHADER_swizzle *swiz,

const unsigned int swizcount,

const MOJOSHADER_samplerMap *smap,

const unsigned int smapcount,

ErrorList *errors)

{

int i, j;

MOJOSHADER_parseData *pd;

MOJOSHADER_malloc m = effect->ctx.m;

MOJOSHADER_free f = effect->ctx.f;

void *d = effect->ctx.malloc_data;

int numobjects = numsmallobjects + numlargeobjects + 1;

for (i = numsmallobjects + 1; i < numobjects; i++)

{

const uint32 technique = readui32(ptr, len);

const uint32 index = readui32(ptr, len);

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

const uint32 state = readui32(ptr, len);

const uint32 type = readui32(ptr, len);

const uint32 length = readui32(ptr, len);

uint32 objectIndex;

if (technique == -1)

objectIndex = effect->params[index].value.valuesSS[state].value.valuesI[0];

else

objectIndex = effect->techniques[technique].passes[index].states[state].value.valuesI[0];

MOJOSHADER_effectObject *object = &effect->objects[objectIndex];

if (object->type == MOJOSHADER_SYMTYPE_PIXELSHADER

|| object->type == MOJOSHADER_SYMTYPE_VERTEXSHADER)

{

object->shader.technique = technique;

object->shader.pass = index;

if (type == 2)

{

/* This is a standalone preshader!

* It exists solely for effect passes that do not use a single

* vertex/fragment shader.

*/

object->shader.is_preshader = 1;

const uint32 start = *((uint32 *) *ptr) + 4;

const char *array = readstring(*ptr, 0, m, d);

object->shader.param_count = 1;

object->shader.params = (uint32 *) m(sizeof (uint32), d);

object->shader.params[0] = findparameter(effect->params,

effect->param_count,

array);

f((void *) array, d);

m, f, d);

// !!! FIXME: check for errors.

object->shader.preshader_param_count = object->shader.preshader->symbol_count;

object->shader.preshader_params = (uint32 *) m(object->shader.preshader_param_count * sizeof (uint32), d);

for (j = 0; j < object->shader.preshader->symbol_count; j++)

{

object->shader.preshader_params[j] = findparameter(effect->params,

effect->param_count,

object->shader.preshader->symbols[j].name);

} // for

} // if

else

{