/**

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

*/

#include <string.h>

#include <assert.h>

#include "../mojoshader.h"

#define __MOJOSHADER_INTERNAL__ 1

#include "../mojoshader_internal.h"

#ifdef MOJOSHADER_HAS_SPIRV_TOOLS

#include "spirv-tools/libspirv.h"

#endif

#ifdef _MSC_VER

#define snprintf _snprintf

#endif

static void *Malloc(int len)

{

void *ptr = malloc(len + sizeof (int));

int *store = (int *) ptr;

printf("malloc() %d bytes (%p)\n", len, ptr);

if (ptr == NULL) return NULL;

*store = len;

return (void *) (store + 1);

} // Malloc

static void Free(void *_ptr)

{

int *ptr = (((int *) _ptr) - 1);

int len = *ptr;

printf("free() %d bytes (%p)\n", len, ptr);

free(ptr);

} // Free

#else

#define Malloc NULL

#define Free NULL

#endif

static inline void do_indent(const unsigned int indent)

{

unsigned int i;

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

printf(" ");

}

#define INDENT() do { if (indent) { do_indent(indent); } } while (0)

{

switch (s)

{

case MOJOSHADER_TYPE_UNKNOWN: return "unknown";

case MOJOSHADER_TYPE_PIXEL: return "pixel";

case MOJOSHADER_TYPE_VERTEX: return "vertex";

case MOJOSHADER_TYPE_GEOMETRY: return "geometry";

} // switch

} // shader_type

static void print_typeinfo(const MOJOSHADER_symbolTypeInfo *info,

unsigned int indent)

{

static const char *symclasses[] = {

"scalar", "vector", "row-major matrix",

"column-major matrix", "object", "struct"

};

static const char *symtypes[] = {

"void", "bool", "int", "float", "string", "texture",

"texture1d", "texture2d", "texture3d", "texturecube",

"sampler", "sampler1d", "sampler2d", "sampler3d",

"samplercube", "pixelshader", "vertexshader", "unsupported"

};

INDENT();

printf(" symbol class %s\n", symclasses[info->parameter_class]);

INDENT();

printf(" symbol type %s\n", symtypes[info->parameter_type]);

INDENT();

printf(" rows %u\n", info->rows);

INDENT();

printf(" columns %u\n", info->columns);

INDENT();

printf(" elements %u\n", info->elements);

if (info->member_count > 0)

{

int i;

INDENT(); printf(" MEMBERS:\n");

for (i = 0; i < info->member_count; i++)

{

const MOJOSHADER_symbolStructMember *member = &info->members[i];

INDENT(); printf(" MEMBERS:\n");

indent++;

INDENT(); printf(" * %d: \"%s\"\n", i, member->name);

print_typeinfo(&member->info, indent);

indent--;

} // for

} // if

} // print_typeinfo

static void print_symbols(const MOJOSHADER_symbol *sym,

const unsigned int symbol_count,

const unsigned int indent)

{

INDENT(); printf("SYMBOLS:");

if (symbol_count == 0)

printf(" (none.)\n");

else

{

int i;

printf("\n");

for (i = 0; i < symbol_count; i++, sym++)

{

static const char *regsets[] = {

"bool", "int4", "float4", "sampler"

};

INDENT(); printf(" * %d: \"%s\"\n", i, sym->name);

INDENT(); printf(" register set %s\n", regsets[sym->register_set]);

INDENT(); printf(" register index %u\n", sym->register_index);

INDENT(); printf(" register count %u\n", sym->register_count);

print_typeinfo(&sym->info, indent);

} // for

printf("\n");

} // else

} // print_symbols

static void print_preshader_operand(const MOJOSHADER_preshader *preshader,

const int instidx, const int opidx)

{

static char mask[] = { 'x', 'y', 'z', 'w' };

const MOJOSHADER_preshaderInstruction *inst = &preshader->instructions[instidx];

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

const int elems = inst->element_count;

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

int i;

switch (operand->type)

{

case MOJOSHADER_PRESHADEROPERAND_LITERAL:

{

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

printf("(");

if (isscalar)

{

const double val = *lit;

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

printf("%g, ", val);

printf("%g)", val);

} // if

else

{

for (i = 0; i < elems-1; i++, lit++)

printf("%g, ", *lit);

printf("%g)", *lit);

} // else

break;

} // case

case MOJOSHADER_PRESHADEROPERAND_INPUT:

case MOJOSHADER_PRESHADEROPERAND_OUTPUT:

case MOJOSHADER_PRESHADEROPERAND_TEMP:

{

int idx = operand->index % 4;

char regch = 'c';

if (operand->type == MOJOSHADER_PRESHADEROPERAND_TEMP)

regch = 'r';

if (operand->array_register_count > 0)

{

for (i = operand->array_register_count - 1; i >= 0; i--)

printf("c%d[", operand->array_registers[i]);

printf("%c%d.%c", regch, operand->index / 4, mask[idx]);

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

printf("]");

break;

} // if

printf("%c%d", regch, operand->index / 4);

if (isscalar)

printf(".%c", mask[idx]);

else if (elems != 4)

{

printf(".");

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

printf("%c", mask[idx++]);

} // else if

break;

} // case

default:

printf("[???{%d, %u}???]", (int) operand->type, operand->index);

break;

} // switch

} // print_preshader_operand

static void print_preshader(const MOJOSHADER_preshader *preshader,

const int indent)

{

MOJOSHADER_preshaderInstruction *inst = preshader->instructions;

static const char *opcodestr[] = {

"asin", "acos", "atan", "min", "max", "lt", "ge", "add", "mul",

"atan2", "div", "cmp", "movc", "dot", "noise", "min", "max", "lt",

"ge", "add", "mul", "atan2", "div", "dot", "noise"

};

INDENT(); printf("PRESHADER:\n");

print_symbols(preshader->symbols, preshader->symbol_count, indent + 1);

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

{

// print dest register first...

print_preshader_operand(preshader, i, inst->operand_count - 1);

// ...then the source registers.

for (j = 0; j < inst->operand_count - 1; j++)

printf(", ");

print_preshader_operand(preshader, i, j);

} // for

printf("\n");

} // for

printf("\n");

} // print_preshader

static void print_attrs(const char *category, const int count,

const MOJOSHADER_attribute *attributes,

const int indent)

{

INDENT(); printf("%s:", category);

if (count == 0)

printf(" (none.)\n");

else

{

int i;

printf("\n");

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

{

static const char *usagenames[] = {

"position", "blendweight", "blendindices", "normal",

"psize", "texcoord", "tangent", "binormal", "tessfactor",

"positiont", "color", "fog", "depth", "sample"

};

const MOJOSHADER_attribute *a = &attributes[i];

char numstr[16] = { 0 };

if (a->index != 0)

snprintf(numstr, sizeof (numstr), "%d", a->index);

INDENT();

if (a->name != NULL)

printf(" (\"%s\")", a->name);

printf("\n");

} // for

} // else

} // print_attrs

static void print_shader(const char *fname, const MOJOSHADER_parseData *pd,

unsigned int indent)

if (pd->error_count > 0)

{

int i;

for (i = 0; i < pd->error_count; i++)

{

const MOJOSHADER_error *err = &pd->errors[i];

INDENT();

err->filename ? err->filename : fname,

err->error_position, err->error);

} // for

} // if

else

{

INDENT(); printf("SHADER TYPE: %s\n", shader_type(pd->shader_type));

INDENT(); printf("VERSION: %d.%d\n", pd->major_ver, pd->minor_ver);

INDENT(); printf("INSTRUCTION COUNT: %d\n", (int) pd->instruction_count);

print_attrs("INPUTS", pd->attribute_count, pd->attributes, indent);

print_attrs("OUTPUTS", pd->output_count, pd->outputs, indent);

if (pd->constant_count == 0)

printf(" (none.)\n");

else

{

int i;

printf("\n");

for (i = 0; i < pd->constant_count; i++)

{

static const char *typenames[] = { "float", "int", "bool" };

const MOJOSHADER_constant *c = &pd->constants[i];

printf(" * %d: %s (", c->index, typenames[(int) c->type]);

if (c->type == MOJOSHADER_UNIFORM_FLOAT)

{

printf("%f %f %f %f", c->value.f[0], c->value.f[1],

c->value.f[2], c->value.f[3]);

} // if

else if (c->type == MOJOSHADER_UNIFORM_INT)

{

printf("%d %d %d %d", c->value.i[0], c->value.i[1],

c->value.i[2], c->value.i[3]);

} // else if

else if (c->type == MOJOSHADER_UNIFORM_BOOL)

{

printf("%s", c->value.b ? "true" : "false");

} // else if

else

{

printf("???");

} // else

printf(")\n");

} // for

} // else

if (pd->uniform_count == 0)

printf(" (none.)\n");

else

{

int i;

printf("\n");

for (i = 0; i < pd->uniform_count; i++)

{

char arrayrange[64] = { '\0' };

if (u->array_count > 0)

{

arrayof = "array[";

snprintf(arrayrange, sizeof (arrayrange), "%d] ",

u->array_count);

} // if

if (u->name != NULL)

printf(" (\"%s\")", u->name);

printf("\n");

} // for

} // else

if (pd->sampler_count == 0)

printf(" (none.)\n");

else

{

int i;

printf("\n");

for (i = 0; i < pd->sampler_count; i++)

{

static const char *typenames[] = { "2d", "cube", "volume" };

const MOJOSHADER_sampler *s = &pd->samplers[i];

printf(" * %d: %s", s->index, typenames[(int) s->type]);

if (s->name != NULL)

printf(" (\"%s\")", s->name);

if (s->texbem)

printf(" [TEXBEM]");

} // for

} // else

if (pd->preshader != NULL)

print_preshader(pd->preshader, indent);

const char *output;

int output_len;

if (strcmp(pd->profile, "spirv") == 0)

{

#if SUPPORT_PROFILE_SPIRV && defined(MOJOSHADER_HAS_SPIRV_TOOLS)

int binary_len = pd->output_len - sizeof(SpirvPatchTable);

uint32_t *words = (uint32_t *) pd->output;

size_t word_count = binary_len / 4;

spv_text text;

spv_diagnostic diagnostic;

spv_context ctx = spvContextCreate(SPV_ENV_UNIVERSAL_1_0);

int options = /*SPV_BINARY_TO_TEXT_OPTION_COLOR |*/ SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES;

spv_result_t disResult = spvBinaryToText(ctx, words, word_count, options, &text, &diagnostic);

if (disResult == SPV_SUCCESS)

{

output = text->str;

output_len = text->length;

} // if

else

{

fprintf(stderr, "\nERROR DIAGNOSTIC: %s\n\n", diagnostic->error);

} // else

spv_result_t validateResult = spvValidateBinary(ctx, words, word_count, &diagnostic);

if (validateResult != SPV_SUCCESS)

{

fprintf(stderr, "\nVALIDATION FAILURE: %s\n\n", diagnostic->error);

} // if

if (disResult != SPV_SUCCESS || validateResult != SPV_SUCCESS)

{

exit(EXIT_FAILURE);

} // if

// FIXME: we're currently just leaking this disassembly...

#else

output = pd->output;

output_len = pd->output_len;

#endif

} // if

else

{

output = pd->output;

output_len = pd->output_len;

} // else

indent++;

INDENT();

putchar((int) output[i]);

if (output[i] == '\n')

INDENT();

} // for

} // print_shader

#ifdef MOJOSHADER_EFFECT_SUPPORT

static void print_value(const MOJOSHADER_effectValue *value,

const unsigned int indent)

{

INDENT();

printf("VALUE: %s -> %s\n", value->name, value->semantic);

static const char *classes[] =

{

"SCALAR",

"VECTOR",

"ROW-MAJOR MATRIX",

"COLUMN-MAJOR MATRIX",

"OBJECT",

"STRUCT"

};

static const char *types[] =

{

"VOID",

"BOOL",

"INT",

"FLOAT",

"STRING",

"TEXTURE",

"TEXTURE1D",

"TEXTURE2D",

"TEXTURE3D",

"TEXTURECUBE",

"SAMPLER",

"SAMPLER1D",

"SAMPLER2D",

"SAMPLER3D",

"SAMPLERCUBE",

"PIXELSHADER",

"VERTEXSHADER",

"UNSUPPORTED"

};

do_indent(indent + 1);

do_indent(indent + 1);

printf("ROWS/COLUMNS/ELEMENTS: %d, %d, %d\n",

do_indent(indent + 1);

printf("TOTAL VALUES: %d\n", value->value_count);

if (value->type.parameter_type == MOJOSHADER_SYMTYPE_SAMPLER

|| value->type.parameter_type == MOJOSHADER_SYMTYPE_SAMPLER1D

|| value->type.parameter_type == MOJOSHADER_SYMTYPE_SAMPLER2D

|| value->type.parameter_type == MOJOSHADER_SYMTYPE_SAMPLER3D

|| value->type.parameter_type == MOJOSHADER_SYMTYPE_SAMPLERCUBE)

{

do_indent(indent + 1);

printf("SAMPLER VALUES:\n");

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

{

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

static const char *samplerstatetypes[] =

{

"UNKNOWN0",

"UNKNOWN1",

"UNKNOWN2",

"UNKNOWN3",

"TEXTURE",

"ADDRESSU",

"ADDRESSV",

"ADDRESSW",

"BORDERCOLOR",

"MAGFILTER",

"MINFILTER",

"MIPFILTER",

"MIPMAPLODBIAS",

"MAXMIPLEVEL",

"MAXANISOTROPY",

"SRGBTEXTURE",

"ELEMENTINDEX",

"DMAPOFFSET",

};

do_indent(indent + 2);

printf("TYPE: %s -> ", samplerstatetypes[state->type]);

/* Assuming only one value per state! */

if (state->type == MOJOSHADER_SAMP_MIPMAPLODBIAS)

{

/* float types */

printf("%.2f\n", *state->value.valuesF);

} // if

else

{

/* int/enum types */

printf("%d\n", *state->value.valuesI);

} // else

} // for

} // if

else

{

do_indent(indent + 1);

i = 0;

do

{

static const char *prints[] =

{

"%X ",

"%d ",

"%d ",

"%.2f ",

"%d ",

"%d ",

"%d ",

"%d ",

"%d ",

"%d ",

"SAMPLER?! ",

"SAMPLER?! ",

"SAMPLER?! ",

"SAMPLER?! ",

"SAMPLER?! ",

"%d ",

"%d ",

"%X "

for (r = 0; r < value->type.rows; r++)

{

do_indent(indent + 2);

for (c = 0; c < value->type.columns; c++)

{

const int offset = (i * value->type.rows * 4) + (r * 4) + c;

if (value->type.parameter_type == MOJOSHADER_SYMTYPE_FLOAT)

printf(prints[value->type.parameter_type], value->valuesF[offset]);

else

printf(prints[value->type.parameter_type], value->valuesI[offset]);

} // for

printf("\n");

} // for

} while (++i < value->type.elements);

} // else

} // print_value

static void print_effect(const char *fname, const MOJOSHADER_effect *effect,

const unsigned int indent)

{

INDENT();

printf("PROFILE: %s\n", effect->profile);

printf("\n");

if (effect->error_count > 0)

{

int i;

for (i = 0; i < effect->error_count; i++)

{

const MOJOSHADER_error *err = &effect->errors[i];

INDENT();

printf("%s:%d: ERROR: %s\n",

err->filename ? err->filename : fname,

err->error_position, err->error);

} // for

} // if

else

{

int i, j, k;

const MOJOSHADER_effectTechnique *technique = effect->techniques;

const MOJOSHADER_effectParam *param = effect->params;

for (i = 0; i < effect->param_count; i++, param++)

{

INDENT();

printf("PARAM #%d\n", i);

print_value(&param->value, indent + 1);

if (param->annotation_count > 0)

{

do_indent(indent + 1);

printf("ANNOTATIONS:\n");

} // if

for (j = 0; j < param->annotation_count; j++)

{

print_value(&param->annotations[j], indent + 2);

} // for

} // for

for (i = 0; i < effect->technique_count; i++, technique++)

{

const MOJOSHADER_effectPass *pass = technique->passes;

INDENT();

printf("TECHNIQUE #%d ('%s'):\n", i, technique->name);

for (j = 0; j < technique->pass_count; j++, pass++)

{

const MOJOSHADER_effectState *state = pass->states;

do_indent(indent + 1);

printf("PASS #%d ('%s'):\n", j, pass->name);

for (k = 0; k < pass->state_count; k++, state++)

{

do_indent(indent + 2);

printf("STATE %d:\n", state->type);

print_value(&state->value, indent + 3);

} // for

} // for

} // for

printf("\n");

/* Start at index 1, 0 is always empty (thanks Microsoft!) */

object++;

for (i = 1; i < effect->object_count; i++, object++)

{

INDENT();

if (object->type == MOJOSHADER_SYMTYPE_PIXELSHADER

|| object->type == MOJOSHADER_SYMTYPE_VERTEXSHADER)

{

if (object->shader.is_preshader)

{

printf("OBJECT #%d: PRESHADER, technique %u, pass %u, param %s\n", i,

object->shader.technique, object->shader.pass,

effect->params[object->shader.params[0]].value.name);

print_preshader(object->shader.preshader, indent + 1);

} // if

else

{

printf("OBJECT #%d: SHADER, technique %u, pass %u\n", i,

object->shader.technique, object->shader.pass);

print_shader(fname, object->shader.shader, indent + 1);

} // else

} // if

else if (object->type == MOJOSHADER_SYMTYPE_STRING)

printf("OBJECT #%d: STRING, '%s'\n", i,

object->string.string);

else if (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)

printf("OBJECT #%d: MAPPING, '%s'\n", i,

object->mapping.name);

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)

printf("OBJECT #%d: TEXTURE\n", i);

else

printf("UNKNOWN OBJECT: #%d\n", i);

} // for

} // else

} // print_effect

#endif // MOJOSHADER_EFFECT_SUPPORT

static int do_parse(const char *fname, const unsigned char *buf,

const int len, const char *prof)

{

int retval = 0;

// magic for an effects file (!!! FIXME: I _think_).

if ( ((buf[0] == 0x01) && (buf[1] == 0x09) &&

(buf[2] == 0xFF) && (buf[3] == 0xFE)) ||

((buf[0] == 0xCF) && (buf[1] == 0x0B) &&

(buf[2] == 0xF0) && (buf[3] == 0xBC)) )

effect = MOJOSHADER_parseEffect(prof, buf, len, NULL, 0,

NULL, 0, Malloc, Free, 0);

int error_count = effect->error_count;

for (i = 0; i < effect->object_count; i++)

{

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

switch (object->type)

{

case MOJOSHADER_SYMTYPE_VERTEXSHADER:

case MOJOSHADER_SYMTYPE_PIXELSHADER:

if (!object->shader.is_preshader)

{

const MOJOSHADER_parseData *shader = object->shader.shader;

if (shader)

error_count += shader->error_count;

} // if

break;

default:

break;

}

}

retval = (error_count == 0);

printf("EFFECT: %s\n", fname);

print_effect(fname, effect, 1);

MOJOSHADER_freeEffect(effect);

#else

printf("Is an effect, but effect support is disabled!\n");

#endif

} // if

else // do it as a regular compiled shader.

{

const MOJOSHADER_parseData *pd;

retval = (pd->error_count == 0);

printf("SHADER: %s\n", fname);

print_shader(fname, pd, 1);

MOJOSHADER_freeParseData(pd);

} // else

return retval;

} // do_parse

int main(int argc, char **argv)

{

int retval = 0;

printf("Compiled against changeset %s\n", MOJOSHADER_CHANGESET);

printf("Linked against changeset %s\n", MOJOSHADER_changeset());

if (argc <= 2)

printf("\n\nUSAGE: %s <profile> [file1] ... [fileN]\n\n", argv[0]);

const char *profile = argv[1];

int i;

for (i = 2; i < argc; i++)

FILE *io = fopen(argv[i], "rb");

if (io == NULL)

else

{

unsigned char *buf = (unsigned char *) malloc(1000000);

int rc = fread(buf, 1, 1000000, io);

fclose(io);

free(buf);

} // else

} // for

} // else

} // main

// end of testparse.c ...