/**

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

 */

#ifndef _INCL_MOJOSHADER_H_

#define _INCL_MOJOSHADER_H_

#ifdef __cplusplus

extern "C" {

#endif

/* You can define this if you aren't generating mojoshader_version.h */

#ifndef MOJOSHADER_NO_VERSION_INCLUDE

#include "mojoshader_version.h"

#endif

#ifndef MOJOSHADER_VERSION

#define MOJOSHADER_VERSION -1

#endif

#ifndef MOJOSHADER_CHANGESET

#define MOJOSHADER_CHANGESET "???"

#endif

/*

 * For determining the version of MojoShader you are using:

 *    const int compiled_against = MOJOSHADER_VERSION;

 *    const int linked_against = MOJOSHADER_version();

 *

 * The version is a single integer that increments, not a major/minor value.

 */

int MOJOSHADER_version(void);

/*

 * For determining the revision control changeset of MojoShader you are using:

 *    const char *compiled_against = MOJOSHADER_CHANGESET;

 *    const char *linked_against = MOJOSHADER_changeset();

 *

 * The version is an arbitrary, null-terminated ASCII string. It is probably

 *  a hash that represents a revision control changeset, and can't be

 *  compared to any other string to determine chronology.

 *

 * Do not attempt to free this string; it's statically allocated.

 */

const char *MOJOSHADER_changeset(void);

/*

 * These allocators work just like the C runtime's malloc() and free()

 *  (in fact, they probably use malloc() and free() internally if you don't

 *  specify your own allocator, but don't rely on that behaviour).

 * (data) is the pointer you supplied when specifying these allocator

 *  callbacks, in case you need instance-specific data...it is passed through

 *  to your allocator unmolested, and can be NULL if you like.

 */

typedef void *(*MOJOSHADER_malloc)(int bytes, void *data);

typedef void (*MOJOSHADER_free)(void *ptr, void *data);

/*

 * These are enum values, but they also can be used in bitmasks, so we can

 *  test if an opcode is acceptable: if (op->shader_types & ourtype) {} ...

 */

typedef enum

{

    MOJOSHADER_TYPE_UNKNOWN  = 0,

    MOJOSHADER_TYPE_PIXEL    = (1 << 0),

    MOJOSHADER_TYPE_VERTEX   = (1 << 1),

    MOJOSHADER_TYPE_GEOMETRY = (1 << 2),  /* (not supported yet.) */

    MOJOSHADER_TYPE_ANY = 0xFFFFFFFF   /* used for bitmasks */

} MOJOSHADER_shaderType;

/*

 * Data types for vertex attribute streams.

 */

typedef enum

{

    MOJOSHADER_ATTRIBUTE_UNKNOWN = -1,  /* housekeeping; not returned. */

    MOJOSHADER_ATTRIBUTE_BYTE,

    MOJOSHADER_ATTRIBUTE_UBYTE,

    MOJOSHADER_ATTRIBUTE_SHORT,

    MOJOSHADER_ATTRIBUTE_USHORT,

    MOJOSHADER_ATTRIBUTE_INT,

    MOJOSHADER_ATTRIBUTE_UINT,

    MOJOSHADER_ATTRIBUTE_FLOAT,

    MOJOSHADER_ATTRIBUTE_DOUBLE,

    MOJOSHADER_ATTRIBUTE_HALF_FLOAT,  /* MAYBE available in your OpenGL! */

} MOJOSHADER_attributeType;

/*

 * Data types for uniforms. See MOJOSHADER_uniform for more information.

 */

typedef enum

{

    MOJOSHADER_UNIFORM_UNKNOWN = -1, /* housekeeping value; never returned. */

    MOJOSHADER_UNIFORM_FLOAT,

    MOJOSHADER_UNIFORM_INT,

    MOJOSHADER_UNIFORM_BOOL,

} MOJOSHADER_uniformType;

/*

 * These are the uniforms to be set for a shader. "Uniforms" are what Direct3D

 *  calls "Constants" ... IDirect3DDevice::SetVertexShaderConstantF() would

 *  need this data, for example. These integers are register indexes. So if

 *  index==6 and type==MOJOSHADER_UNIFORM_FLOAT, that means we'd expect a

 *  4-float vector to be specified for what would be register "c6" in D3D

 *  assembly language, before drawing with the shader.

 * (array_count) means this is an array of uniforms...this happens in some

 *  profiles when we see a relative address ("c0[a0.x]", not the usual "c0").

 *  In those cases, the shader was built to set some range of constant

 *  registers as an array. You should set this array with (array_count)

 *  elements from the constant register file, starting at (index) instead of

 *  just a single uniform. To be extra difficult, you'll need to fill in the

 *  correct values from the MOJOSHADER_constant data into the appropriate

 *  parts of the array, overriding the constant register file. Fun!

 * (constant) says whether this is a constant array; these need to be loaded

 *  once at creation time, from the constant list and not ever updated from

 *  the constant register file. This is a workaround for limitations in some

 *  profiles.

 * (name) is a profile-specific variable name; it may be NULL if it isn't

 *  applicable to the requested profile.

 */

typedef struct MOJOSHADER_uniform

{

    MOJOSHADER_uniformType type;

    int index;

    int array_count;

    int constant;

    const char *name;

} MOJOSHADER_uniform;

/*

 * These are the constants defined in a shader. These are data values

 *  hardcoded in a shader (with the DEF, DEFI, DEFB instructions), which

 *  override your Uniforms. This data is largely for informational purposes,

 *  since they are compiled in and can't be changed, like Uniforms can be.

 * These integers are register indexes. So if index==6 and

 *  type==MOJOSHADER_UNIFORM_FLOAT, that means we'd expect a 4-float vector

 *  to be specified for what would be register "c6" in D3D assembly language,

 *  before drawing with the shader.

 * (value) is the value of the constant, unioned by type.

 */

typedef struct MOJOSHADER_constant

{

    MOJOSHADER_uniformType type;

    int index;

    union

    {

        float f[4];  /* if type==MOJOSHADER_UNIFORM_FLOAT */

        int i[4];    /* if type==MOJOSHADER_UNIFORM_INT */

        int b;       /* if type==MOJOSHADER_UNIFORM_BOOL */

    } value;

} MOJOSHADER_constant;

/*

 * Data types for samplers. See MOJOSHADER_sampler for more information.

 */

typedef enum

{

    MOJOSHADER_SAMPLER_UNKNOWN = -1, /* housekeeping value; never returned. */

    MOJOSHADER_SAMPLER_2D,

    MOJOSHADER_SAMPLER_CUBE,

    MOJOSHADER_SAMPLER_VOLUME,

} MOJOSHADER_samplerType;

/*

 * These are the samplers to be set for a shader. ...

 *  IDirect3DDevice::SetTexture() would need this data, for example.

 * These integers are the sampler "stage". So if index==6 and

 *  type==MOJOSHADER_SAMPLER_2D, that means we'd expect a regular 2D texture

 *  to be specified for what would be register "s6" in D3D assembly language,

 *  before drawing with the shader.

 * (name) is a profile-specific variable name; it may be NULL if it isn't

 *  applicable to the requested profile.

 */

typedef struct MOJOSHADER_sampler

{

    MOJOSHADER_samplerType type;

    int index;

    const char *name;

} MOJOSHADER_sampler;

/*

 * Data types for attributes. See MOJOSHADER_attribute for more information.

 */

typedef enum

{

    MOJOSHADER_USAGE_UNKNOWN = -1,  /* housekeeping value; never returned. */

    MOJOSHADER_USAGE_POSITION,

    MOJOSHADER_USAGE_BLENDWEIGHT,

    MOJOSHADER_USAGE_BLENDINDICES,

    MOJOSHADER_USAGE_NORMAL,

    MOJOSHADER_USAGE_POINTSIZE,

    MOJOSHADER_USAGE_TEXCOORD,

    MOJOSHADER_USAGE_TANGENT,

    MOJOSHADER_USAGE_BINORMAL,

    MOJOSHADER_USAGE_TESSFACTOR,

    MOJOSHADER_USAGE_POSITIONT,

    MOJOSHADER_USAGE_COLOR,

    MOJOSHADER_USAGE_FOG,

    MOJOSHADER_USAGE_DEPTH,

    MOJOSHADER_USAGE_SAMPLE,

    MOJOSHADER_USAGE_TOTAL,  /* housekeeping value; never returned. */

} MOJOSHADER_usage;

/*

 * These are the attributes to be set for a shader. "Attributes" are what

 *  Direct3D calls "Vertex Declarations Usages" ...

 *  IDirect3DDevice::CreateVertexDeclaration() would need this data, for

 *  example. Each attribute is associated with an array of data that uses one

 *  element per-vertex. So if usage==MOJOSHADER_USAGE_COLOR and index==1, that

 *  means we'd expect a secondary color array to be bound to this shader

 *  before drawing.

 * (name) is a profile-specific variable name; it may be NULL if it isn't

 *  applicable to the requested profile.

 */

typedef struct MOJOSHADER_attribute

{

    MOJOSHADER_usage usage;

    int index;

    const char *name;

} MOJOSHADER_attribute;

/*

 * Use this if you want to specify newly-parsed code to swizzle incoming

 *  data. This can be useful if you know, at parse time, that a shader

 *  will be processing data on COLOR0 that should be RGBA, but you'll

 *  be passing it a vertex array full of ARGB instead.

 */

typedef struct MOJOSHADER_swizzle

{

    MOJOSHADER_usage usage;

    unsigned int index;

    unsigned char swizzles[4];  /* {0,1,2,3} == .xyzw, {2,2,2,2} == .zzzz */

} MOJOSHADER_swizzle;

/*

 * MOJOSHADER_symbol data.

 *

 * These are used to expose high-level information in shader bytecode.

 *  They associate HLSL variables with registers. This data is used for both

 *  debugging and optimization.

 */

typedef enum

{

    MOJOSHADER_SYMREGSET_BOOL,

    MOJOSHADER_SYMREGSET_INT4,

    MOJOSHADER_SYMREGSET_FLOAT4,

    MOJOSHADER_SYMREGSET_SAMPLER,

} MOJOSHADER_symbolRegisterSet;

typedef enum

{

    MOJOSHADER_SYMCLASS_SCALAR,

    MOJOSHADER_SYMCLASS_VECTOR,

    MOJOSHADER_SYMCLASS_MATRIX_ROWS,

    MOJOSHADER_SYMCLASS_MATRIX_COLUMNS,

    MOJOSHADER_SYMCLASS_OBJECT,

    MOJOSHADER_SYMCLASS_STRUCT,

} MOJOSHADER_symbolClass;

typedef enum

{

    MOJOSHADER_SYMTYPE_VOID,

    MOJOSHADER_SYMTYPE_BOOL,

    MOJOSHADER_SYMTYPE_INT,

    MOJOSHADER_SYMTYPE_FLOAT,

    MOJOSHADER_SYMTYPE_STRING,

    MOJOSHADER_SYMTYPE_TEXTURE,

    MOJOSHADER_SYMTYPE_TEXTURE1D,

    MOJOSHADER_SYMTYPE_TEXTURE2D,

    MOJOSHADER_SYMTYPE_TEXTURE3D,

    MOJOSHADER_SYMTYPE_TEXTURECUBE,

    MOJOSHADER_SYMTYPE_SAMPLER,

    MOJOSHADER_SYMTYPE_SAMPLER1D,

    MOJOSHADER_SYMTYPE_SAMPLER2D,

    MOJOSHADER_SYMTYPE_SAMPLER3D,

    MOJOSHADER_SYMTYPE_SAMPLERCUBE,

    MOJOSHADER_SYMTYPE_PIXELSHADER,

    MOJOSHADER_SYMTYPE_VERTEXSHADER,

    MOJOSHADER_SYMTYPE_PIXELFRAGMENT,

    MOJOSHADER_SYMTYPE_VERTEXFRAGMENT,

    MOJOSHADER_SYMTYPE_UNSUPPORTED,

} MOJOSHADER_symbolType;

typedef struct MOJOSHADER_symbolStructMember MOJOSHADER_symbolStructMember;

typedef struct MOJOSHADER_symbolTypeInfo

{

    MOJOSHADER_symbolClass parameter_class;

    MOJOSHADER_symbolType parameter_type;

    unsigned int rows;

    unsigned int columns;

    unsigned int elements;

    unsigned int member_count;

    MOJOSHADER_symbolStructMember *members;

} MOJOSHADER_symbolTypeInfo;

struct MOJOSHADER_symbolStructMember

{

    const char *name;

    MOJOSHADER_symbolTypeInfo info;

};

typedef struct MOJOSHADER_symbol

{

    const char *name;

    MOJOSHADER_symbolRegisterSet register_set;

    unsigned int register_index;

    unsigned int register_count;

    MOJOSHADER_symbolTypeInfo info;

} MOJOSHADER_symbol;

/*

 * These are used with MOJOSHADER_error as special case positions.

 */

#define MOJOSHADER_POSITION_NONE (-3)

#define MOJOSHADER_POSITION_BEFORE (-2)

#define MOJOSHADER_POSITION_AFTER (-1)

typedef struct MOJOSHADER_error

{

    /*

     * Human-readable error, if there is one. Will be NULL if there was no

     *  error. The string will be UTF-8 encoded, and English only. Most of

     *  these shouldn't be shown to the end-user anyhow.

     */

    const char *error;

    /*

     * Filename where error happened. This can be NULL if the information

     *  isn't available.

     */

    const char *filename;

    /*

     * Position of error, if there is one. Will be MOJOSHADER_POSITION_NONE if

     *  there was no error, MOJOSHADER_POSITION_BEFORE if there was an error

     *  before processing started, and MOJOSHADER_POSITION_AFTER if there was

     *  an error during final processing. If >= 0, MOJOSHADER_parse() sets

     *  this to the byte offset (starting at zero) into the bytecode you

     *  supplied, and MOJOSHADER_assemble(), MOJOSHADER_parseAst(), and

     *  MOJOSHADER_compile() sets this to a a line number in the source code

     *  you supplied (starting at one).

     */

    int error_position;

} MOJOSHADER_error;

/* !!! FIXME: document me. */

typedef enum MOJOSHADER_preshaderOpcode

{

    MOJOSHADER_PRESHADEROP_NOP,

    MOJOSHADER_PRESHADEROP_MOV,

    MOJOSHADER_PRESHADEROP_NEG,

    MOJOSHADER_PRESHADEROP_RCP,

    MOJOSHADER_PRESHADEROP_FRC,

    MOJOSHADER_PRESHADEROP_EXP,

    MOJOSHADER_PRESHADEROP_LOG,

    MOJOSHADER_PRESHADEROP_RSQ,

    MOJOSHADER_PRESHADEROP_SIN,

    MOJOSHADER_PRESHADEROP_COS,

    MOJOSHADER_PRESHADEROP_ASIN,

    MOJOSHADER_PRESHADEROP_ACOS,

    MOJOSHADER_PRESHADEROP_ATAN,

    MOJOSHADER_PRESHADEROP_MIN,

    MOJOSHADER_PRESHADEROP_MAX,

    MOJOSHADER_PRESHADEROP_ADD,

    MOJOSHADER_PRESHADEROP_MUL,

    MOJOSHADER_PRESHADEROP_ATAN2,

    MOJOSHADER_PRESHADEROP_DIV,

    MOJOSHADER_PRESHADEROP_CMP,

    MOJOSHADER_PRESHADEROP_MOVC,

    MOJOSHADER_PRESHADEROP_DOT,

    MOJOSHADER_PRESHADEROP_NOISE,

    MOJOSHADER_PRESHADEROP_SCALAR_OPS,

    MOJOSHADER_PRESHADEROP_MIN_SCALAR = MOJOSHADER_PRESHADEROP_SCALAR_OPS,

    MOJOSHADER_PRESHADEROP_MAX_SCALAR,

    MOJOSHADER_PRESHADEROP_ADD_SCALAR,

    MOJOSHADER_PRESHADEROP_MUL_SCALAR,

    MOJOSHADER_PRESHADEROP_ATAN2_SCALAR,

    MOJOSHADER_PRESHADEROP_DIV_SCALAR,

    MOJOSHADER_PRESHADEROP_DOT_SCALAR,

    MOJOSHADER_PRESHADEROP_NOISE_SCALAR,

} MOJOSHADER_preshaderOpcode;

typedef enum MOJOSHADER_preshaderOperandType

{

    MOJOSHADER_PRESHADEROPERAND_INPUT,

    MOJOSHADER_PRESHADEROPERAND_OUTPUT,

    MOJOSHADER_PRESHADEROPERAND_LITERAL,

    MOJOSHADER_PRESHADEROPERAND_TEMP,

} MOJOSHADER_preshaderOperandType;

typedef struct MOJOSHADER_preshaderOperand

{

    MOJOSHADER_preshaderOperandType type;

    unsigned int index;

} MOJOSHADER_preshaderOperand;

typedef struct MOJOSHADER_preshaderInstruction

{

    MOJOSHADER_preshaderOpcode opcode;

    unsigned int element_count;

    unsigned int operand_count;

    MOJOSHADER_preshaderOperand operands[3];

} MOJOSHADER_preshaderInstruction;

typedef struct MOJOSHADER_preshader

{

    unsigned int literal_count;

    double *literals;

    unsigned int temp_count;  /* scalar, not vector! */

    unsigned int instruction_count;

    MOJOSHADER_preshaderInstruction *instructions;

} MOJOSHADER_preshader;

/*

 * Structure used to return data from parsing of a shader...

 */

/* !!! FIXME: most of these ints should be unsigned. */

typedef struct MOJOSHADER_parseData

{

    /*

     * The number of elements pointed to by (errors).

     */

    int error_count;

    /*

     * (error_count) elements of data that specify errors that were generated

     *  by parsing this shader.

     * This can be NULL if there were no errors or if (error_count) is zero.

     */

    MOJOSHADER_error *errors;

    /*

     * The name of the profile used to parse the shader. Will be NULL on error.

     */

    const char *profile;

    /*

     * Bytes of output from parsing. Most profiles produce a string of source

     *  code, but profiles that do binary output may not be text at all.

     *  Will be NULL on error.

     */

    const char *output;

    /*

     * Byte count for output, not counting any null terminator. Most profiles

     *  produce an ASCII string of source code (which will be null-terminated

     *  even though that null char isn't included in output_len), but profiles

     *  that do binary output may not be text at all. Will be 0 on error.

     */

    int output_len;

    /*

     * Count of Direct3D instruction slots used. This is meaningless in terms

     *  of the actual output, as the profile will probably grow or reduce

     *  the count (or for high-level languages, not have that information at

     *  all). Also, as with Microsoft's own assembler, this value is just a

     *  rough estimate, as unpredicable real-world factors make the actual

     *  value vary at least a little from this count. Still, it can give you

     *  a rough idea of the size of your shader. Will be zero on error.

     */

    int instruction_count;

    /*

     * The type of shader we parsed. Will be MOJOSHADER_TYPE_UNKNOWN on error.

     */

    MOJOSHADER_shaderType shader_type;

    /*

     * The shader's major version. If this was a "vs_3_0", this would be 3.

     */

    int major_ver;

    /*

     * The shader's minor version. If this was a "ps_1_4", this would be 4.