rhino/demo/c/dr_libs/old/dr_mtl.h

Go to the documentation of this file.

// Public Domain. See "unlicense" statement at the end of this file.
 
// ABOUT
//
// dr_mtl is a library for loading materials for use in 2D or 3D graphics. But it's a bit different to
// what you may expect. It does not reprsent materials as a static data, but rather as a series of
// instructions that interface with a set of inputs. Indeed, this library is more like a compiler - you
// specify an input file (such as a Wavefront MTL file), compile it into an intermediate bytecode
// represenation, and then run it through a code generator to generate shader code such as GLSL, HLSL,
// Spir-V, etc.
//
//
//
// USAGE
//
// This is a single-file library. To use it, do something like the following in one .c file.
//   #define DR_MTL_IMPLEMENTATION
//   #include "dr_mtl.h"
//
// You can then #include dr_mtl.h in other parts of the program as you would with any other header file.
//
//
//
// OPTIONS
//
// #define DRMTL_NO_MTL_COMPILER
//   Disables the Wavefront MTL compiler.
//
// #define DRMTL_NO_GLSL_CODEGEN
//   Disables the GLSL code generator.
//
//
//
// TODO
// - Add more documentation.
// - Add a demo to demonstrate the awesomeness of this library.
// - Add trigonometric instructions.
 
#ifndef dr_mtl_h
#define dr_mtl_h
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stddef.h>
#include <stdbool.h>
 
#if defined(_MSC_VER)
    #pragma warning(push)
    #pragma warning(disable:4201)   // Non-standard extension used: nameless struct/union.
#endif
 
 
#define DRMTL_MAGIC_NUMBER        0x81DF7405
#define DRMTL_CURRENT_VERSION     1
 
#define DRMTL_INPUT_DESC_CONSTI   ((unsigned char)-2)
#define DRMTL_INPUT_DESC_CONSTF   ((unsigned char)-1)
#define DRMTL_INPUT_DESC_VARX     ((unsigned char)0)
#define DRMTL_INPUT_DESC_VARY     ((unsigned char)1)
#define DRMTL_INPUT_DESC_VARZ     ((unsigned char)2)
#define DRMTL_INPUT_DESC_VARW     ((unsigned char)3)
 
#define DRMTL_MAX_IDENTIFIER_NAME 28
#define DRMTL_MAX_CHANNEL_NAME    28
#define DRMTL_MAX_PROPERTY_NAME   28
 
#define DRMTL_MAX_INPUT_PATH      252
#define DRMTL_MAX_PROPERTY_PATH   224
 
 
typedef unsigned char drmtl_uint8;
typedef unsigned int  drmtl_uint32;
 
typedef struct drmtl_material drmtl_material;
 
 
typedef enum
{
    drmtl_type_float   = 1,
    drmtl_type_float2  = 2,
    drmtl_type_float3  = 3,
    drmtl_type_float4  = 4,
    drmtl_type_int     = 5,
    drmtl_type_int2    = 6,
    drmtl_type_int3    = 7,
    drmtl_type_int4    = 8,
    drmtl_type_tex1d   = 9,
    drmtl_type_tex2d   = 10,
    drmtl_type_tex3d   = 11,
    drmtl_type_texcube = 12,
    drmtl_type_bool    = 13
 
} drmtl_type;
 
typedef enum
{
    // Assignment
 
    // mov
    drmtl_opcode_movf1 = 0x00000001,
    drmtl_opcode_movf2 = 0x00000002,
    drmtl_opcode_movf3 = 0x00000003,
    drmtl_opcode_movf4 = 0x00000004,
    drmtl_opcode_movi1 = 0x00000005,
    drmtl_opcode_movi2 = 0x00000006,
    drmtl_opcode_movi3 = 0x00000007,
    drmtl_opcode_movi4 = 0x00000008,
 
 
    // Arithmetic
 
    // add
    drmtl_opcode_addf1 = 0x00001001,
    drmtl_opcode_addf2 = 0x00001002,
    drmtl_opcode_addf3 = 0x00001003,
    drmtl_opcode_addf4 = 0x00001004,
    drmtl_opcode_addi1 = 0x00001005,
    drmtl_opcode_addi2 = 0x00001006,
    drmtl_opcode_addi3 = 0x00001007,
    drmtl_opcode_addi4 = 0x00001008,
 
    // sub
    drmtl_opcode_subf1 = 0x00001101,
    drmtl_opcode_subf2 = 0x00001102,
    drmtl_opcode_subf3 = 0x00001103,
    drmtl_opcode_subf4 = 0x00001104,
    drmtl_opcode_subi1 = 0x00001105,
    drmtl_opcode_subi2 = 0x00001106,
    drmtl_opcode_subi3 = 0x00001107,
    drmtl_opcode_subi4 = 0x00001108,
 
    // mul
    drmtl_opcode_mulf1 = 0x00001201,
    drmtl_opcode_mulf2 = 0x00001202,
    drmtl_opcode_mulf3 = 0x00001203,
    drmtl_opcode_mulf4 = 0x00001204,
    drmtl_opcode_muli1 = 0x00001205,
    drmtl_opcode_muli2 = 0x00001206,
    drmtl_opcode_muli3 = 0x00001207,
    drmtl_opcode_muli4 = 0x00001208,
 
    // div
    drmtl_opcode_divf1 = 0x00001301,
    drmtl_opcode_divf2 = 0x00001302,
    drmtl_opcode_divf3 = 0x00001303,
    drmtl_opcode_divf4 = 0x00001304,
    drmtl_opcode_divi1 = 0x00001305,
    drmtl_opcode_divi2 = 0x00001306,
    drmtl_opcode_divi3 = 0x00001307,
    drmtl_opcode_divi4 = 0x00001308,
 
    // pow
    drmtl_opcode_powf1 = 0x00001401,
    drmtl_opcode_powf2 = 0x00001402,
    drmtl_opcode_powf3 = 0x00001403,
    drmtl_opcode_powf4 = 0x00001404,
    drmtl_opcode_powi1 = 0x00001405,
    drmtl_opcode_powi2 = 0x00001406,
    drmtl_opcode_powi3 = 0x00001407,
    drmtl_opcode_powi4 = 0x00001408,
 
 
    // Textures
 
    // tex
    drmtl_opcode_tex1    = 0x00002001,
    drmtl_opcode_tex2    = 0x00002002,
    drmtl_opcode_tex3    = 0x00002003,
    drmtl_opcode_texcube = 0x00002004,
 
 
    // Miscellaneous
 
    // var
    drmtl_opcode_var   = 0x00003000,
 
    // ret
    drmtl_opcode_retf1 = 0x00003001,
    drmtl_opcode_retf2 = 0x00003002,
    drmtl_opcode_retf3 = 0x00003003,
    drmtl_opcode_retf4 = 0x00003004,
    drmtl_opcode_reti1 = 0x00003005,
    drmtl_opcode_reti2 = 0x00003006,
    drmtl_opcode_reti3 = 0x00003007,
    drmtl_opcode_reti4 = 0x00003008
 
} drmtl_opcode;
 
 
typedef struct
{
    drmtl_type type;
 
    char name[DRMTL_MAX_IDENTIFIER_NAME];
 
} drmtl_identifier;
 
 
typedef struct
{
    unsigned int identifierIndex;
 
    union
    {
                struct
        {
            float x;
        } f1;
        struct
        {
            float x;
            float y;
        } f2;
        struct
        {
            float x;
            float y;
            float z;
        } f3;
        struct
        {
            float x;
            float y;
            float z;
            float w;
        } f4;
 
        struct
        {
            int x;
        } i1;
        struct
        {
            int x;
            int y;
        } i2;
        struct
        {
            int x;
            int y;
            int z;
        } i3;
        struct
        {
            int x;
            int y;
            int z;
            int w;
        } i4;
 
        struct
        {
            char value[DRMTL_MAX_INPUT_PATH];   // Enough room for a path, but less to keep the total size of the structure at 256 bytes. Null terminated.
        } path;
 
 
        struct
        {
            drmtl_uint32 x;
            drmtl_uint32 y;
            drmtl_uint32 z;
            drmtl_uint32 w;
        } raw4;
    };
 
} drmtl_input;
 
 
typedef struct
{
    drmtl_type type;
 
    char name[DRMTL_MAX_CHANNEL_NAME];
 
} drmtl_channel;
 
 
typedef union
{
    unsigned int id;
 
    float valuef;
 
    int valuei;
 
}drmtl_instruction_input;
 
 
typedef struct
{
    unsigned char x;
    unsigned char y;
    unsigned char z;
    unsigned char w;
 
} drmtl_instruction_input_descriptor;
 
typedef struct
{
    drmtl_opcode opcode;
 
        union
        {
        // mov data.
                struct
                {
            drmtl_instruction_input_descriptor inputDesc;
                        drmtl_instruction_input inputX;
            drmtl_instruction_input inputY;
            drmtl_instruction_input inputZ;
            drmtl_instruction_input inputW;
            unsigned int output;
                } mov;
 
 
        // add data.
        struct
        {
            drmtl_instruction_input_descriptor inputDesc;
            drmtl_instruction_input inputX;
            drmtl_instruction_input inputY;
            drmtl_instruction_input inputZ;
            drmtl_instruction_input inputW;
            unsigned int output;
        } add;
 
        // sub data.
        struct
        {
            drmtl_instruction_input_descriptor inputDesc;
            drmtl_instruction_input inputX;
            drmtl_instruction_input inputY;
            drmtl_instruction_input inputZ;
            drmtl_instruction_input inputW;
            unsigned int output;
        } sub;
 
        // mul data.
        struct
        {
            drmtl_instruction_input_descriptor inputDesc;
            drmtl_instruction_input inputX;
            drmtl_instruction_input inputY;
            drmtl_instruction_input inputZ;
            drmtl_instruction_input inputW;
            unsigned int output;
        } mul;
 
        // div data.
        struct
        {
            drmtl_instruction_input_descriptor inputDesc;
            drmtl_instruction_input inputX;
            drmtl_instruction_input inputY;
            drmtl_instruction_input inputZ;
            drmtl_instruction_input inputW;
            unsigned int output;
        } div;
 
        // pow data.
        struct
        {
            drmtl_instruction_input_descriptor inputDesc;
            drmtl_instruction_input inputX;
            drmtl_instruction_input inputY;
            drmtl_instruction_input inputZ;
            drmtl_instruction_input inputW;
            unsigned int output;
        } pow;
 
 
        // tex data.
        struct
        {
            drmtl_instruction_input_descriptor inputDesc;
            drmtl_instruction_input inputX;
            drmtl_instruction_input inputY;
            drmtl_instruction_input inputZ;
            drmtl_instruction_input inputW;
            unsigned int texture;
            unsigned int output;
        } tex;
 
 
        // ret data.
        struct
        {
            drmtl_instruction_input_descriptor inputDesc;
            drmtl_instruction_input inputX;
            drmtl_instruction_input inputY;
            drmtl_instruction_input inputZ;
            drmtl_instruction_input inputW;
        } ret;
 
 
        // var data
        struct
        {
            //drmtl_type type;
            unsigned int identifierIndex;
        } var;
 
 
        // Ensures the size of the instruction is always 32 bytes.
        struct
        {
            drmtl_uint8 _unused[32];
        } unused;
        };
 
} drmtl_instruction;
 
 
typedef struct
{
    drmtl_type type;
 
    char name[DRMTL_MAX_PROPERTY_NAME];
 
    union
    {
        struct
        {
            float x;
        } f1;
        struct
        {
            float x;
            float y;
        } f2;
        struct
        {
            float x;
            float y;
            float z;
        } f3;
        struct
        {
            float x;
            float y;
            float z;
            float w;
        } f4;
 
        struct
        {
            int x;
        } i1;
        struct
        {
            int x;
            int y;
        } i2;
        struct
        {
            int x;
            int y;
            int z;
        } i3;
        struct
        {
            int x;
            int y;
            int z;
            int w;
        } i4;
 
        struct
        {
            char value[DRMTL_MAX_PROPERTY_PATH];        // Enough room for a path, but less to keep the total size of the structure at 256 bytes. Null terminated.
        } path;
 
        struct
        {
            int x;
        } b1;
    };
 
} drmtl_property;
 
 
typedef struct
{
    unsigned int magic;
 
    unsigned int version;
 
 
    unsigned int identifierSizeInBytes;
 
    unsigned int inputSizeInBytes;
 
    unsigned int channelHeaderSizeInBytes;
 
    unsigned int instructionSizeInBytes;
 
    unsigned int propertySizeInBytes;
 
 
    unsigned int identifierCount;
 
    unsigned int privateInputCount;
 
    unsigned int publicInputCount;
 
    unsigned int channelCount;
 
    unsigned int propertyCount;
 
 
    unsigned int identifiersOffset;
 
    unsigned int inputsOffset;
 
    unsigned int channelsOffset;
 
    unsigned int propertiesOffset;
 
 
} drmtl_header;
 
typedef struct
{
    drmtl_channel channel;
 
    unsigned int instructionCount;
 
} drmtl_channel_header;
 
 
struct drmtl_material
{
    drmtl_uint8* pRawData;
 
    unsigned int sizeInBytes;
 
    unsigned int bufferSizeInBytes;
 
 
    unsigned int currentStage;
 
    unsigned int currentChannelOffset;
 
 
    bool ownsRawData;
};
 
 
 
// Low-Level APIs
//
// Use these APIs to work on materials directly. Note that these are intentionally restrictive in that things can
// be added to the material, however they can never be removed. In addition, everything must be added in order which
// means identifiers need to be added first, followed by private inputs, followed by public inputs, followed by
// channels, followed by properties.
//
// Use these to construct a material after everything has been processed at a higher level.
 
bool drmtl_init(drmtl_material* pMaterial);
bool drmtl_initfromexisting(drmtl_material* pMaterial, const void* pRawData, unsigned int dataSizeInBytes);
bool drmtl_initfromexisting_nocopy(drmtl_material* pMaterial, const void* pRawData, unsigned int dataSizeInBytes);
 
void drmtl_uninit(drmtl_material* pMaterial);
 
 
drmtl_header* drmtl_getheader(drmtl_material* pMaterial);
 
 
bool drmtl_appendidentifier(drmtl_material* pMaterial, drmtl_identifier identifier, unsigned int* indexOut);
 
bool drmtl_appendprivateinput(drmtl_material* pMaterial, drmtl_input input);
 
bool drmtl_appendpublicinput(drmtl_material* pMaterial, drmtl_input input);
 
bool drmtl_appendchannel(drmtl_material* pMaterial, drmtl_channel channelHeader);
 
bool drmtl_appendinstruction(drmtl_material* pMaterial, drmtl_instruction instruction);
 
bool drmtl_appendproperty(drmtl_material* pMaterial, drmtl_property prop);
 
 
drmtl_channel_header* drmtl_getchannelheaderbyindex(drmtl_material* pMaterial, unsigned int channelIndex);
 
drmtl_channel_header* drmtl_getchannelheaderbyname(drmtl_material* pMaterial, const char* channelName);
 
 
drmtl_identifier* drmtl_getidentifiers(drmtl_material* pMaterial);
drmtl_identifier* drmtl_getidentifier(drmtl_material* pMaterial, unsigned int index);
 
unsigned int drmtl_getidentifiercount(drmtl_material* pMaterial);
 
 
unsigned int drmtl_getinputcount(drmtl_material* pMaterial);
 
drmtl_input* drmtl_getinputbyindex(drmtl_material* pMaterial, unsigned int index);
 
unsigned int drmtl_getprivateinputcount(drmtl_material* pMaterial);
 
drmtl_input* drmtl_getprivateinputbyindex(drmtl_material* pMaterial, unsigned int index);
 
unsigned int drmtl_getpublicinputcount(drmtl_material* pMaterial);
 
drmtl_input* drmtl_getpublicinputbyindex(drmtl_material* pMaterial, unsigned int index);
 
 
unsigned int drmtl_getpropertycount(drmtl_material* pMaterial);
 
drmtl_property* drmtl_getpropertybyindex(drmtl_material* pMaterial, unsigned int index);
 
drmtl_property* drmtl_getpropertybyname(drmtl_material* pMaterial, const char* name);
 
 
 
// Mid-Level APIs
 
drmtl_identifier drmtl_identifier_float(const char* name);
drmtl_identifier drmtl_identifier_float2(const char* name);
drmtl_identifier drmtl_identifier_float3(const char* name);
drmtl_identifier drmtl_identifier_float4(const char* name);
drmtl_identifier drmtl_identifier_int(const char* name);
drmtl_identifier drmtl_identifier_int2(const char* name);
drmtl_identifier drmtl_identifier_int3(const char* name);
drmtl_identifier drmtl_identifier_int4(const char* name);
drmtl_identifier drmtl_identifier_tex2d(const char* name);
 
drmtl_input drmtl_input_float(unsigned int identifierIndex, float x);
drmtl_input drmtl_input_float2(unsigned int identifierIndex, float x, float y);
drmtl_input drmtl_input_float3(unsigned int identifierIndex, float x, float y, float z);
drmtl_input drmtl_input_float4(unsigned int identifierIndex, float x, float y, float z, float w);
drmtl_input drmtl_input_int(unsigned int identifierIndex, int x);
drmtl_input drmtl_input_int2(unsigned int identifierIndex, int x, int y);
drmtl_input drmtl_input_int3(unsigned int identifierIndex, int x, int y, int z);
drmtl_input drmtl_input_int4(unsigned int identifierIndex, int x, int y, int z, int w);
drmtl_input drmtl_input_tex(unsigned int identifierIndex, const char* path);
 
drmtl_channel drmtl_channel_float(const char* name);
drmtl_channel drmtl_channel_float2(const char* name);
drmtl_channel drmtl_channel_float3(const char* name);
drmtl_channel drmtl_channel_float4(const char* name);
drmtl_channel drmtl_channel_int(const char* name);
drmtl_channel drmtl_channel_int2(const char* name);
drmtl_channel drmtl_channel_int3(const char* name);
drmtl_channel drmtl_channel_int4(const char* name);
 
drmtl_instruction drmtl_movf1_v1(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_movf1_c1(unsigned int outputIdentifierIndex, float x);
drmtl_instruction drmtl_movf2_v2(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_movf2_c2(unsigned int outputIdentifierIndex, float x, float y);
drmtl_instruction drmtl_movf3_v3(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_movf3_c3(unsigned int outputIdentifierIndex, float x, float y, float z);
drmtl_instruction drmtl_movf4_v4(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_movf4_c4(unsigned int outputIdentifierIndex, float x, float y, float z, float w);
 
drmtl_instruction drmtl_addf1_v1(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_addf1_c1(unsigned int outputIdentifierIndex, float x);
drmtl_instruction drmtl_addf2_v2(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_addf2_c2(unsigned int outputIdentifierIndex, float x, float y);
drmtl_instruction drmtl_addf3_v3(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_addf3_c3(unsigned int outputIdentifierIndex, float x, float y, float z);
drmtl_instruction drmtl_addf4_v4(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_addf4_c4(unsigned int outputIdentifierIndex, float x, float y, float z, float w);
 
drmtl_instruction drmtl_subf1_v1(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_subf1_c1(unsigned int outputIdentifierIndex, float x);
drmtl_instruction drmtl_subf2_v2(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_subf2_c2(unsigned int outputIdentifierIndex, float x, float y);
drmtl_instruction drmtl_subf3_v3(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_subf3_c3(unsigned int outputIdentifierIndex, float x, float y, float z);
drmtl_instruction drmtl_subf4_v4(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_subf4_c4(unsigned int outputIdentifierIndex, float x, float y, float z, float w);
 
drmtl_instruction drmtl_mulf1_v1(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_mulf1_c1(unsigned int outputIdentifierIndex, float x);
drmtl_instruction drmtl_mulf2_v2(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_mulf2_c2(unsigned int outputIdentifierIndex, float x, float y);
drmtl_instruction drmtl_mulf3_v3(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_mulf3_c3(unsigned int outputIdentifierIndex, float x, float y, float z);
drmtl_instruction drmtl_mulf4_v4(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_mulf4_c4(unsigned int outputIdentifierIndex, float x, float y, float z, float w);
drmtl_instruction drmtl_mulf4_v3v1(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndexXYZ, unsigned int inputIdentifierIndexW);
drmtl_instruction drmtl_mulf4_v3c1(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex, float w);
drmtl_instruction drmtl_mulf4_v2c2(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex, float z, float w);
drmtl_instruction drmtl_mulf4_v1c3(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex, float y, float z, float w);
drmtl_instruction drmtl_mulf4_v1v1v1v1(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndexX, unsigned int inputIdentifierIndexY, unsigned int inputIdentifierIndexZ, unsigned int inputIdentifierIndexW);
 
drmtl_instruction drmtl_divf1_v1(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_divf1_c1(unsigned int outputIdentifierIndex, float x);
drmtl_instruction drmtl_divf2_v2(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_divf2_c2(unsigned int outputIdentifierIndex, float x, float y);
drmtl_instruction drmtl_divf3_v3(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_divf3_c3(unsigned int outputIdentifierIndex, float x, float y, float z);
drmtl_instruction drmtl_divf4_v4(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex);
drmtl_instruction drmtl_divf4_c4(unsigned int outputIdentifierIndex, float x, float y, float z, float w);
 
drmtl_instruction drmtl_tex2(unsigned int outputIdentifierIndex, unsigned int textureIdentifierIndex, unsigned int texcoordIdentifierIndex);
drmtl_instruction drmtl_var(unsigned int identifierIndex);
drmtl_instruction drmtl_retf1(unsigned int identifierIndex);
drmtl_instruction drmtl_retf2(unsigned int identifierIndex);
drmtl_instruction drmtl_retf3(unsigned int identifierIndex);
drmtl_instruction drmtl_retf4(unsigned int identifierIndex);
drmtl_instruction drmtl_retf1_c1(float x);
drmtl_instruction drmtl_retf2_c2(float x, float y);
drmtl_instruction drmtl_retf3_c3(float x, float y, float z);
drmtl_instruction drmtl_retf4_c4(float x, float y, float z, float w);
drmtl_instruction drmtl_reti1(unsigned int identifierIndex);
drmtl_instruction drmtl_reti2(unsigned int identifierIndex);
drmtl_instruction drmtl_reti3(unsigned int identifierIndex);
drmtl_instruction drmtl_reti4(unsigned int identifierIndex);
drmtl_instruction drmtl_reti1_c1(int x);
drmtl_instruction drmtl_reti2_c2(int x, int y);
drmtl_instruction drmtl_reti3_c3(int x, int y, int z);
drmtl_instruction drmtl_reti4_c4(int x, int y, int z, int w);
 
drmtl_property drmtl_property_float(const char* name, float x);
drmtl_property drmtl_property_float2(const char* name, float x, float y);
drmtl_property drmtl_property_float3(const char* name, float x, float y, float z);
drmtl_property drmtl_property_float4(const char* name, float x, float y, float z, float w);
drmtl_property drmtl_property_int(const char* name, int x);
drmtl_property drmtl_property_int2(const char* name, int x, int y);
drmtl_property drmtl_property_int3(const char* name, int x, int y, int z);
drmtl_property drmtl_property_int4(const char* name, int x, int y, int z, int w);
drmtl_property drmtl_property_bool(const char* name, bool value);
 
 
 
 
//
// Compilers
//
 
#ifndef DRMTL_NO_MTL_COMPILER
bool drmtl_compile_wavefront_mtl(drmtl_material* pMaterial, const char* mtlData, size_t mtlDataSizeInBytes, const char* texcoordInputName);
#endif
 
 
 
 
//
// Code Generators
//
 
#ifndef DRMTL_NO_GLSL_CODEGEN
bool drmtl_codegen_glsl_channel(drmtl_material* pMaterial, const char* channelName, char* codeOut, size_t codeOutSizeInBytes, size_t* pBytesWrittenOut);
 
bool drmtl_codegen_glsl_uniforms(drmtl_material* pMaterial, char* codeOut, size_t codeOutSizeInBytes, size_t* pBytesWritteOut);
#endif
 
 
 
 
 
#if defined(_MSC_VER)
    #pragma warning(pop)
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif  //dr_mtl_h
 
 
//
// IMPLEMENTATION
//
#ifdef DR_MTL_IMPLEMENTATION
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <limits.h>
 
#if defined(__clang__)
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wcast-align"
#endif
 
 
// When constructing the material's raw data, memory is allocated in blocks of this amount. This must be at least 256.
#define DRMTL_CHUNK_SIZE              4096
 
#define DRMTL_STAGE_IDS               0
#define DRMTL_STAGE_PRIVATE_INPUTS    1
#define DRMTL_STAGE_PUBLIC_INPUTS     2
#define DRMTL_STAGE_CHANNELS          3
#define DRMTL_STAGE_PROPERTIES        4
#define DRMTL_STAGE_COMPLETE          UINT_MAX
 
 
// Utilities
 
// strcpy()
static int drmtl_strcpy(char* dst, size_t dstSizeInBytes, const char* src)
{
#if defined(_MSC_VER)
    return strcpy_s(dst, dstSizeInBytes, src);
#else
    if (dst == 0) {
        return EINVAL;
    }
    if (dstSizeInBytes == 0) {
        return ERANGE;
    }
    if (src == 0) {
        dst[0] = '\0';
        return EINVAL;
    }
 
    char* iDst = dst;
    const char* iSrc = src;
    size_t remainingSizeInBytes = dstSizeInBytes;
    while (remainingSizeInBytes > 0 && iSrc[0] != '\0')
    {
        iDst[0] = iSrc[0];
 
        iDst += 1;
        iSrc += 1;
        remainingSizeInBytes -= 1;
    }
 
    if (remainingSizeInBytes > 0) {
        iDst[0] = '\0';
    } else {
        dst[0] = '\0';
        return ERANGE;
    }
 
    return 0;
#endif
}
 
 
 
bool _drmtl_inflate(drmtl_material* pMaterial);
 
 
bool drmtl_init(drmtl_material* pMaterial)
{
    if (pMaterial != NULL)
    {
        assert(DRMTL_CHUNK_SIZE >= 256);
 
        pMaterial->pRawData = (drmtl_uint8*)malloc(DRMTL_CHUNK_SIZE);
        if (pMaterial->pRawData != NULL)
        {
            pMaterial->sizeInBytes          = sizeof(drmtl_header);
            pMaterial->bufferSizeInBytes    = DRMTL_CHUNK_SIZE;
            pMaterial->currentStage         = DRMTL_STAGE_IDS;
            pMaterial->currentChannelOffset = 0;
            pMaterial->ownsRawData          = 1;
 
            drmtl_header* pHeader = drmtl_getheader(pMaterial);
            assert(pHeader != NULL);
 
            pHeader->magic                    = DRMTL_MAGIC_NUMBER;
            pHeader->version                  = DRMTL_CURRENT_VERSION;
            pHeader->identifierSizeInBytes    = sizeof(drmtl_identifier);
            pHeader->inputSizeInBytes         = sizeof(drmtl_input);
            pHeader->channelHeaderSizeInBytes = sizeof(drmtl_channel_header);
            pHeader->instructionSizeInBytes   = sizeof(drmtl_instruction);
            pHeader->propertySizeInBytes      = sizeof(drmtl_property);
            pHeader->identifierCount          = 0;
            pHeader->privateInputCount        = 0;
            pHeader->publicInputCount         = 0;
            pHeader->channelCount             = 0;
            pHeader->propertyCount            = 0;
            pHeader->identifiersOffset        = pMaterial->sizeInBytes;
            pHeader->inputsOffset             = pMaterial->sizeInBytes;
            pHeader->channelsOffset           = pMaterial->sizeInBytes;
            pHeader->propertiesOffset         = pMaterial->sizeInBytes;
 
            return 1;
        }
    }
 
    return 0;
}
 
bool drmtl_initfromexisting(drmtl_material* pMaterial, const void* pRawData, unsigned int dataSizeInBytes)
{
    if (pMaterial != NULL)
    {
        if (pRawData != NULL && dataSizeInBytes >= sizeof(drmtl_header))
        {
            if (((drmtl_header*)pMaterial->pRawData)->magic == DRMTL_MAGIC_NUMBER)
            {
                pMaterial->pRawData = (drmtl_uint8*)malloc(DRMTL_CHUNK_SIZE);
                if (pMaterial->pRawData != NULL)
                {
                    memcpy(pMaterial->pRawData, pRawData, dataSizeInBytes);
                    pMaterial->sizeInBytes          = dataSizeInBytes;
                    pMaterial->bufferSizeInBytes    = dataSizeInBytes;
                    pMaterial->currentStage         = DRMTL_STAGE_COMPLETE;
                    pMaterial->currentChannelOffset = 0;
                    pMaterial->ownsRawData          = 1;
 
                    return 1;
                }
            }
        }
    }
 
    return 0;
}
 
bool drmtl_initfromexisting_nocopy(drmtl_material* pMaterial, const void* pRawData, unsigned int dataSizeInBytes)
{
    if (pMaterial != NULL)
    {
        if (pRawData != NULL && dataSizeInBytes >= sizeof(drmtl_header))
        {
            if (((const drmtl_header*)pRawData)->magic == DRMTL_MAGIC_NUMBER)
            {
                pMaterial->pRawData             = (drmtl_uint8*)pRawData;
                pMaterial->sizeInBytes          = dataSizeInBytes;
                pMaterial->bufferSizeInBytes    = dataSizeInBytes;
                pMaterial->currentStage         = DRMTL_STAGE_COMPLETE;
                pMaterial->currentChannelOffset = 0;
                pMaterial->ownsRawData          = 0;
 
                return 1;
            }
        }
    }
 
    return 0;
}
 
void drmtl_uninit(drmtl_material* pMaterial)
{
    if (pMaterial != NULL)
    {
        if (pMaterial->ownsRawData)
        {
            free(pMaterial->pRawData);
        }
 
        pMaterial->pRawData = NULL;
    }
}
 
 
drmtl_header* drmtl_getheader(drmtl_material* pMaterial)
{
    if (pMaterial != NULL)
    {
        return (drmtl_header*)pMaterial->pRawData;
    }
 
    return NULL;
}
 
 
bool drmtl_appendidentifier(drmtl_material* pMaterial, drmtl_identifier identifier, unsigned int* indexOut)
{
    if (pMaterial != NULL)
    {
        if (pMaterial->currentStage <= DRMTL_STAGE_IDS)
        {
            drmtl_header* pHeader = drmtl_getheader(pMaterial);
            if (pHeader != NULL)
            {
                if (pMaterial->sizeInBytes + pHeader->identifierSizeInBytes > pMaterial->bufferSizeInBytes)
                {
                    if (!_drmtl_inflate(pMaterial))
                    {
                        // An error occured when trying to inflate the buffer. Might be out of memory.
                        return 0;
                    }
 
                    pHeader = drmtl_getheader(pMaterial);
                    assert(pMaterial->sizeInBytes + pHeader->identifierSizeInBytes <= pMaterial->bufferSizeInBytes);
                }
 
 
                memcpy(pMaterial->pRawData + pHeader->inputsOffset, &identifier, pHeader->identifierSizeInBytes);
                pMaterial->sizeInBytes += pHeader->identifierSizeInBytes;
 
                pHeader->identifierCount  += 1;
                pHeader->inputsOffset     += pHeader->identifierSizeInBytes;
                pHeader->channelsOffset   += pHeader->identifierSizeInBytes;
                pHeader->propertiesOffset += pHeader->identifierSizeInBytes;
 
 
                if (indexOut != NULL)
                {
                    *indexOut = pHeader->identifierCount - 1;
                }
 
                return 1;
            }
        }
    }
 
    return 0;
}
 
bool drmtl_appendprivateinput(drmtl_material* pMaterial, drmtl_input input)
{
    if (pMaterial != NULL)
    {
        if (pMaterial->currentStage <= DRMTL_STAGE_PRIVATE_INPUTS)
        {
            drmtl_header* pHeader = drmtl_getheader(pMaterial);
            if (pHeader != NULL)
            {
                if (pMaterial->sizeInBytes + pHeader->inputSizeInBytes > pMaterial->bufferSizeInBytes)
                {
                    if (!_drmtl_inflate(pMaterial))
                    {
                        // An error occured when trying to inflate the buffer. Might be out of memory.
                        return 0;
                    }
 
                    pHeader = drmtl_getheader(pMaterial);
                    assert(pMaterial->sizeInBytes + pHeader->inputSizeInBytes <= pMaterial->bufferSizeInBytes);
                }
 
 
                memcpy(pMaterial->pRawData + pHeader->channelsOffset, &input, pHeader->inputSizeInBytes);
                pMaterial->sizeInBytes += pHeader->inputSizeInBytes;
 
                pHeader->privateInputCount += 1;
                pHeader->channelsOffset    += pHeader->inputSizeInBytes;
                pHeader->propertiesOffset  += pHeader->inputSizeInBytes;
 
 
                pMaterial->currentStage = DRMTL_STAGE_PRIVATE_INPUTS;
                return 1;
            }
        }
    }
 
    return 0;
}
 
bool drmtl_appendpublicinput(drmtl_material* pMaterial, drmtl_input input)
{
    if (pMaterial != NULL)
    {
        if (pMaterial->currentStage <= DRMTL_STAGE_PUBLIC_INPUTS)
        {
            drmtl_header* pHeader = drmtl_getheader(pMaterial);
            if (pHeader != NULL)
            {
                if (pMaterial->sizeInBytes + pHeader->inputSizeInBytes > pMaterial->bufferSizeInBytes)
                {
                    if (!_drmtl_inflate(pMaterial))
                    {
                        // An error occured when trying to inflate the buffer. Might be out of memory.
                        return 0;
                    }
 
                    pHeader = drmtl_getheader(pMaterial);
                    assert(pMaterial->sizeInBytes + pHeader->inputSizeInBytes <= pMaterial->bufferSizeInBytes);
                }
 
 
                memcpy(pMaterial->pRawData + pHeader->channelsOffset, &input, pHeader->inputSizeInBytes);
                pMaterial->sizeInBytes += pHeader->inputSizeInBytes;
 
                pHeader->publicInputCount  += 1;
                pHeader->channelsOffset    += pHeader->inputSizeInBytes;
                pHeader->propertiesOffset  += pHeader->inputSizeInBytes;
 
 
                pMaterial->currentStage = DRMTL_STAGE_PUBLIC_INPUTS;
                return 1;
            }
        }
    }
 
    return 0;
}
 
bool drmtl_appendchannel(drmtl_material* pMaterial, drmtl_channel channel)
{
    if (pMaterial != NULL)
    {
        if (pMaterial->currentStage <= DRMTL_STAGE_CHANNELS)
        {
            drmtl_header* pHeader = drmtl_getheader(pMaterial);
            if (pHeader != NULL)
            {
                drmtl_channel_header channelHeader;
                channelHeader.channel         = channel;
                channelHeader.instructionCount = 0;
 
                if (pMaterial->sizeInBytes + pHeader->channelHeaderSizeInBytes > pMaterial->bufferSizeInBytes)
                {
                    if (!_drmtl_inflate(pMaterial))
                    {
                        // An error occured when trying to inflate the buffer. Might be out of memory.
                        return 0;
                    }
 
                    pHeader = drmtl_getheader(pMaterial);
                    assert(pMaterial->sizeInBytes + pHeader->channelHeaderSizeInBytes <= pMaterial->bufferSizeInBytes);
                }
 
 
                memcpy(pMaterial->pRawData + pHeader->propertiesOffset, &channelHeader, pHeader->channelHeaderSizeInBytes);
                pMaterial->currentChannelOffset = pMaterial->sizeInBytes;
                pMaterial->sizeInBytes += pHeader->channelHeaderSizeInBytes;
 
                pHeader->channelCount     += 1;
                pHeader->propertiesOffset += pHeader->channelHeaderSizeInBytes;
 
 
                pMaterial->currentStage = DRMTL_STAGE_CHANNELS;
                return 1;
            }
        }
    }
 
    return 0;
}
 
bool drmtl_appendinstruction(drmtl_material* pMaterial, drmtl_instruction instruction)
{
    if (pMaterial != NULL)
    {
        if (pMaterial->currentStage == DRMTL_STAGE_CHANNELS)
        {
            drmtl_header* pHeader = drmtl_getheader(pMaterial);
            if (pHeader != NULL)
            {
                if (pMaterial->sizeInBytes + pHeader->instructionSizeInBytes > pMaterial->bufferSizeInBytes)
                {
                    if (!_drmtl_inflate(pMaterial))
                    {
                        // An error occured when trying to inflate the buffer. Might be out of memory.
                        return 0;
                    }
 
                    pHeader = drmtl_getheader(pMaterial);
                    assert(pMaterial->sizeInBytes + pHeader->instructionSizeInBytes <= pMaterial->bufferSizeInBytes);
                }
 
 
                memcpy(pMaterial->pRawData + pHeader->propertiesOffset, &instruction, pHeader->instructionSizeInBytes);
                pMaterial->sizeInBytes += pHeader->instructionSizeInBytes;
 
                drmtl_channel_header* pChannelHeader = (drmtl_channel_header*)(pMaterial->pRawData + pMaterial->currentChannelOffset);
                if (pChannelHeader != NULL)
                {
                    pChannelHeader->instructionCount += 1;
                }
 
                pHeader->propertiesOffset += pHeader->instructionSizeInBytes;
 
 
                return 1;
            }
        }
    }
 
    return 0;
}
 
bool drmtl_appendproperty(drmtl_material* pMaterial, drmtl_property prop)
{
    if (pMaterial != NULL)
    {
        if (pMaterial->currentStage <= DRMTL_STAGE_CHANNELS)
        {
            drmtl_header* pHeader = drmtl_getheader(pMaterial);
            if (pHeader != NULL)
            {
                if (pMaterial->sizeInBytes + pHeader->propertySizeInBytes > pMaterial->bufferSizeInBytes)
                {
                    if (!_drmtl_inflate(pMaterial))
                    {
                        // An error occured when trying to inflate the buffer. Might be out of memory.
                        return 0;
                    }
 
                    pHeader = drmtl_getheader(pMaterial);
                    assert(pMaterial->sizeInBytes + pHeader->propertySizeInBytes <= pMaterial->bufferSizeInBytes);
                }
 
 
                memcpy(pMaterial->pRawData + pMaterial->sizeInBytes, &prop, pHeader->propertySizeInBytes);
                pMaterial->sizeInBytes += pHeader->propertySizeInBytes;
 
                pHeader->propertyCount += 1;
 
 
                pMaterial->currentStage = DRMTL_STAGE_PROPERTIES;
                return 1;
            }
        }
    }
 
    return 0;
}
 
 
drmtl_channel_header* drmtl_getchannelheaderbyindex(drmtl_material* pMaterial, unsigned int channelIndex)
{
    if (pMaterial != NULL)
    {
        drmtl_header* pHeader = drmtl_getheader(pMaterial);
        assert(pHeader != NULL);
 
        if (channelIndex < pHeader->channelCount)
        {
            drmtl_uint8* pChannelHeader = pMaterial->pRawData + pHeader->channelsOffset;
            for (unsigned int iChannel = 0; iChannel < channelIndex; ++iChannel)
            {
                pChannelHeader += sizeof(drmtl_channel_header) + (sizeof(drmtl_instruction) * ((drmtl_channel_header*)pChannelHeader)->instructionCount);
            }
 
            return (drmtl_channel_header*)pChannelHeader;
        }
    }
 
    return NULL;
}
 
drmtl_channel_header* drmtl_getchannelheaderbyname(drmtl_material* pMaterial, const char* channelName)
{
    if (pMaterial != NULL)
    {
        drmtl_header* pHeader = drmtl_getheader(pMaterial);
        assert(pHeader != NULL);
 
        drmtl_uint8* pChannelHeader = pMaterial->pRawData + pHeader->channelsOffset;
        for (unsigned int iChannel = 0; iChannel < pHeader->channelCount; ++iChannel)
        {
            if (strcmp(((drmtl_channel_header*)pChannelHeader)->channel.name, channelName) == 0)
            {
                return (drmtl_channel_header*)pChannelHeader;
            }
 
            pChannelHeader += sizeof(drmtl_channel_header) + (sizeof(drmtl_instruction) * ((drmtl_channel_header*)pChannelHeader)->instructionCount);
        }
    }
 
    return NULL;
}
 
drmtl_identifier* drmtl_getidentifiers(drmtl_material* pMaterial)
{
    if (pMaterial != NULL)
    {
        drmtl_header* pHeader = drmtl_getheader(pMaterial);
        assert(pHeader != NULL);
 
        return (drmtl_identifier*)(pMaterial->pRawData + pHeader->identifiersOffset);
    }
 
    return NULL;
}
 
drmtl_identifier* drmtl_getidentifier(drmtl_material* pMaterial, unsigned int index)
{
    if (pMaterial != NULL)
    {
        drmtl_header* pHeader = drmtl_getheader(pMaterial);
        assert(pHeader != NULL);
 
        if (index < pHeader->identifierCount)
        {
            drmtl_identifier* firstIdentifier = (drmtl_identifier*)(pMaterial->pRawData + pHeader->identifiersOffset);
            return firstIdentifier + index;
        }
    }
 
    return NULL;
}
 
unsigned int drmtl_getidentifiercount(drmtl_material* pMaterial)
{
    if (pMaterial != NULL)
    {
        drmtl_header* pHeader = drmtl_getheader(pMaterial);
        assert(pHeader != NULL);
 
        return pHeader->identifierCount;
    }
 
    return 0;
}
 
 
unsigned int drmtl_getinputcount(drmtl_material* pMaterial)
{
    if (pMaterial != NULL)
    {
        drmtl_header* pHeader = drmtl_getheader(pMaterial);
        assert(pHeader != NULL);
 
        return pHeader->privateInputCount + pHeader->publicInputCount;
    }
 
    return 0;
}
 
drmtl_input* drmtl_getinputbyindex(drmtl_material* pMaterial, unsigned int index)
{
    if (pMaterial != NULL)
    {
        drmtl_header* pHeader = drmtl_getheader(pMaterial);
        assert(pHeader != NULL);
 
        if (index < (pHeader->privateInputCount + pHeader->publicInputCount))
        {
            drmtl_input* firstInput = (drmtl_input*)(pMaterial->pRawData + pHeader->inputsOffset);
            return firstInput + index;
        }
    }
 
    return NULL;
}
 
unsigned int drmtl_getprivateinputcount(drmtl_material* pMaterial)
{
    if (pMaterial != NULL)
    {
        drmtl_header* pHeader = drmtl_getheader(pMaterial);
        assert(pHeader != NULL);
 
        return pHeader->privateInputCount;
    }
 
    return 0;
}
 
drmtl_input* drmtl_getprivateinputbyindex(drmtl_material* pMaterial, unsigned int index)
{
    if (pMaterial != NULL)
    {
        drmtl_header* pHeader = drmtl_getheader(pMaterial);
        assert(pHeader != NULL);
 
        if (index < pHeader->privateInputCount)
        {
            drmtl_input* firstInput = (drmtl_input*)(pMaterial->pRawData + pHeader->inputsOffset);
            return firstInput + index;
        }
    }
 
    return NULL;
}
 
unsigned int drmtl_getpublicinputcount(drmtl_material* pMaterial)
{
    if (pMaterial != NULL)
    {
        drmtl_header* pHeader = drmtl_getheader(pMaterial);
        assert(pHeader != NULL);
 
        return pHeader->publicInputCount;
    }
 
    return 0;
}
 
drmtl_input* drmtl_getpublicinputbyindex(drmtl_material* pMaterial, unsigned int index)
{
    if (pMaterial != NULL)
    {
        drmtl_header* pHeader = drmtl_getheader(pMaterial);
        assert(pHeader != NULL);
 
        if (index < pHeader->publicInputCount)
        {
            drmtl_input* firstInput = (drmtl_input*)(pMaterial->pRawData + pHeader->inputsOffset);
            return firstInput + pHeader->privateInputCount + index;
        }
    }
 
    return NULL;
}
 
 
unsigned int drmtl_getpropertycount(drmtl_material* pMaterial)
{
    if (pMaterial != NULL)
    {
        drmtl_header* pHeader = drmtl_getheader(pMaterial);
        assert(pHeader != NULL);
 
        return pHeader->propertyCount;
    }
 
    return 0;
}
 
drmtl_property* drmtl_getpropertybyindex(drmtl_material* pMaterial, unsigned int index)
{
    if (pMaterial != NULL)
    {
        drmtl_header* pHeader = drmtl_getheader(pMaterial);
        assert(pHeader != NULL);
 
        if (index < pHeader->propertyCount)
        {
            drmtl_property* firstProperty = (drmtl_property*)(pMaterial->pRawData + pHeader->propertiesOffset);
            return firstProperty + index;
        }
    }
 
    return NULL;
}
 
drmtl_property* drmtl_getpropertybyname(drmtl_material* pMaterial, const char* name)
{
    if (pMaterial != NULL)
    {
        drmtl_header* pHeader = drmtl_getheader(pMaterial);
        assert(pHeader != NULL);
 
        for (unsigned int i = 0; i < pHeader->propertyCount; ++i)
        {
            drmtl_property* pProperty = ((drmtl_property*)(pMaterial->pRawData + pHeader->propertiesOffset)) + i;
            assert(pProperty != NULL);
 
            if (strcmp(pProperty->name, name) == 0)
            {
                return pProperty;
            }
        }
    }
 
    return NULL;
}
 
 
// Private low-level API.
 
bool _drmtl_inflate(drmtl_material* pMaterial)
{
    assert(pMaterial != NULL);
 
    drmtl_uint8* pOldBuffer = pMaterial->pRawData;
    drmtl_uint8* pNewBuffer = (drmtl_uint8*)malloc(pMaterial->bufferSizeInBytes + DRMTL_CHUNK_SIZE);
    if (pNewBuffer != NULL)
    {
        memcpy(pNewBuffer, pOldBuffer, pMaterial->sizeInBytes);
        pMaterial->pRawData = pNewBuffer;
        pMaterial->bufferSizeInBytes += DRMTL_CHUNK_SIZE;
 
        free(pOldBuffer);
        return 1;
    }
 
    return 0;
}
 
 
 
// Mid-Level APIs
 
drmtl_identifier drmtl_identifier_float(const char* name)
{
    drmtl_identifier identifier;
    identifier.type = drmtl_type_float;
    drmtl_strcpy(identifier.name, DRMTL_MAX_IDENTIFIER_NAME, name);
 
    return identifier;
}
 
drmtl_identifier drmtl_identifier_float2(const char* name)
{
    drmtl_identifier identifier;
    identifier.type = drmtl_type_float2;
    drmtl_strcpy(identifier.name, DRMTL_MAX_IDENTIFIER_NAME, name);
 
    return identifier;
}
 
drmtl_identifier drmtl_identifier_float3(const char* name)
{
    drmtl_identifier identifier;
    identifier.type = drmtl_type_float3;
    drmtl_strcpy(identifier.name, DRMTL_MAX_IDENTIFIER_NAME, name);
 
    return identifier;
}
 
drmtl_identifier drmtl_identifier_float4(const char* name)
{
    drmtl_identifier identifier;
    identifier.type = drmtl_type_float4;
    drmtl_strcpy(identifier.name, DRMTL_MAX_IDENTIFIER_NAME, name);
 
    return identifier;
}
 
drmtl_identifier drmtl_identifier_int(const char* name)
{
    drmtl_identifier identifier;
    identifier.type = drmtl_type_int;
    drmtl_strcpy(identifier.name, DRMTL_MAX_IDENTIFIER_NAME, name);
 
    return identifier;
}
 
drmtl_identifier drmtl_identifier_int2(const char* name)
{
    drmtl_identifier identifier;
    identifier.type = drmtl_type_int2;
    drmtl_strcpy(identifier.name, DRMTL_MAX_IDENTIFIER_NAME, name);
 
    return identifier;
}
 
drmtl_identifier drmtl_identifier_int3(const char* name)
{
    drmtl_identifier identifier;
    identifier.type = drmtl_type_int3;
    drmtl_strcpy(identifier.name, DRMTL_MAX_IDENTIFIER_NAME, name);
 
    return identifier;
}
 
drmtl_identifier drmtl_identifier_int4(const char* name)
{
    drmtl_identifier identifier;
    identifier.type = drmtl_type_int4;
    drmtl_strcpy(identifier.name, DRMTL_MAX_IDENTIFIER_NAME, name);
 
    return identifier;
}
 
drmtl_identifier drmtl_identifier_tex2d(const char* name)
{
    drmtl_identifier identifier;
    identifier.type = drmtl_type_tex2d;
    drmtl_strcpy(identifier.name, DRMTL_MAX_IDENTIFIER_NAME, name);
 
    return identifier;
}
 
 
drmtl_input drmtl_input_float(unsigned int identifierIndex, float x)
{
    drmtl_input input;
    input.identifierIndex = identifierIndex;
    input.f1.x = x;
 
    return input;
}
 
drmtl_input drmtl_input_float2(unsigned int identifierIndex, float x, float y)
{
    drmtl_input input;
    input.identifierIndex = identifierIndex;
    input.f2.x = x;
    input.f2.y = y;
 
    return input;
}
 
drmtl_input drmtl_input_float3(unsigned int identifierIndex, float x, float y, float z)
{
    drmtl_input input;
    input.identifierIndex = identifierIndex;
    input.f3.x = x;
    input.f3.y = y;
    input.f3.z = z;
 
    return input;
}
 
drmtl_input drmtl_input_float4(unsigned int identifierIndex, float x, float y, float z, float w)
{
    drmtl_input input;
    input.identifierIndex = identifierIndex;
    input.f4.x = x;
    input.f4.y = y;
    input.f4.z = z;
    input.f4.w = w;
 
    return input;
}
 
drmtl_input drmtl_input_int(unsigned int identifierIndex, int x)
{
    drmtl_input input;
    input.identifierIndex = identifierIndex;
    input.i1.x = x;
 
    return input;
}
 
drmtl_input drmtl_input_int2(unsigned int identifierIndex, int x, int y)
{
    drmtl_input input;
    input.identifierIndex = identifierIndex;
    input.i2.x = x;
    input.i2.y = y;
 
    return input;
}
 
drmtl_input drmtl_input_int3(unsigned int identifierIndex, int x, int y, int z)
{
    drmtl_input input;
    input.identifierIndex = identifierIndex;
    input.i3.x = x;
    input.i3.y = y;
    input.i3.z = z;
 
    return input;
}
 
drmtl_input drmtl_input_int4(unsigned int identifierIndex, int x, int y, int z, int w)
{
    drmtl_input input;
    input.identifierIndex = identifierIndex;
    input.i4.x = x;
    input.i4.y = y;
    input.i4.z = z;
    input.i4.w = w;
 
    return input;
}
 
drmtl_input drmtl_input_tex(unsigned int identifierIndex, const char* path)
{
    drmtl_input input;
    input.identifierIndex = identifierIndex;
    drmtl_strcpy(input.path.value, DRMTL_MAX_INPUT_PATH, path);
 
    return input;
}
 
 
drmtl_channel drmtl_channel_float(const char* name)
{
    drmtl_channel channel;
    channel.type = drmtl_type_float;
    drmtl_strcpy(channel.name, DRMTL_MAX_CHANNEL_NAME, name);
 
    return channel;
}
 
drmtl_channel drmtl_channel_float2(const char* name)
{
    drmtl_channel channel;
    channel.type = drmtl_type_float2;
    drmtl_strcpy(channel.name, DRMTL_MAX_CHANNEL_NAME, name);
 
    return channel;
}
 
drmtl_channel drmtl_channel_float3(const char* name)
{
    drmtl_channel channel;
    channel.type = drmtl_type_float3;
    drmtl_strcpy(channel.name, DRMTL_MAX_CHANNEL_NAME, name);
 
    return channel;
}
 
drmtl_channel drmtl_channel_float4(const char* name)
{
    drmtl_channel channel;
    channel.type = drmtl_type_float4;
    drmtl_strcpy(channel.name, DRMTL_MAX_CHANNEL_NAME, name);
 
    return channel;
}
 
drmtl_channel drmtl_channel_int(const char* name)
{
    drmtl_channel channel;
    channel.type = drmtl_type_int;
    drmtl_strcpy(channel.name, DRMTL_MAX_CHANNEL_NAME, name);
 
    return channel;
}
 
drmtl_channel drmtl_channel_int2(const char* name)
{
    drmtl_channel channel;
    channel.type = drmtl_type_int2;
    drmtl_strcpy(channel.name, DRMTL_MAX_CHANNEL_NAME, name);
 
    return channel;
}
 
drmtl_channel drmtl_channel_int3(const char* name)
{
    drmtl_channel channel;
    channel.type = drmtl_type_int3;
    drmtl_strcpy(channel.name, DRMTL_MAX_CHANNEL_NAME, name);
 
    return channel;
}
 
drmtl_channel drmtl_channel_int4(const char* name)
{
    drmtl_channel channel;
    channel.type = drmtl_type_int4;
    drmtl_strcpy(channel.name, DRMTL_MAX_CHANNEL_NAME, name);
 
    return channel;
}
 
 
drmtl_instruction drmtl_movf1_v1(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_movf1;
    inst.mov.inputDesc.x = DRMTL_INPUT_DESC_VARX;
    inst.mov.inputX.id   = inputIdentifierIndex;
    inst.mov.output      = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_movf1_c1(unsigned int outputIdentifierIndex, float x)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_movf1;
    inst.mov.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.mov.inputX.valuef = x;
    inst.mov.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_movf2_v2(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_movf2;
    inst.mov.inputDesc.x = DRMTL_INPUT_DESC_VARX;
    inst.mov.inputDesc.y = DRMTL_INPUT_DESC_VARY;
    inst.mov.inputX.id   = inputIdentifierIndex;
    inst.mov.inputY.id   = inputIdentifierIndex;
    inst.mov.output      = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_movf2_c2(unsigned int outputIdentifierIndex, float x, float y)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_movf2;
    inst.mov.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.mov.inputDesc.y   = DRMTL_INPUT_DESC_CONSTF;
    inst.mov.inputX.valuef = x;
    inst.mov.inputY.valuef = y;
    inst.mov.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_movf3_v3(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_movf3;
    inst.mov.inputDesc.x = DRMTL_INPUT_DESC_VARX;
    inst.mov.inputDesc.y = DRMTL_INPUT_DESC_VARY;
    inst.mov.inputDesc.z = DRMTL_INPUT_DESC_VARZ;
    inst.mov.inputX.id   = inputIdentifierIndex;
    inst.mov.inputY.id   = inputIdentifierIndex;
    inst.mov.inputZ.id   = inputIdentifierIndex;
    inst.mov.output      = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_movf3_c3(unsigned int outputIdentifierIndex, float x, float y, float z)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_movf3;
    inst.mov.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.mov.inputDesc.y   = DRMTL_INPUT_DESC_CONSTF;
    inst.mov.inputDesc.z   = DRMTL_INPUT_DESC_CONSTF;
    inst.mov.inputX.valuef = x;
    inst.mov.inputY.valuef = y;
    inst.mov.inputZ.valuef = z;
    inst.mov.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_movf4_v4(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_movf4;
    inst.mov.inputDesc.x = DRMTL_INPUT_DESC_VARX;
    inst.mov.inputDesc.y = DRMTL_INPUT_DESC_VARY;
    inst.mov.inputDesc.z = DRMTL_INPUT_DESC_VARZ;
    inst.mov.inputDesc.w = DRMTL_INPUT_DESC_VARW;
    inst.mov.inputX.id   = inputIdentifierIndex;
    inst.mov.inputY.id   = inputIdentifierIndex;
    inst.mov.inputZ.id   = inputIdentifierIndex;
    inst.mov.inputW.id   = inputIdentifierIndex;
    inst.mov.output      = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_movf4_c4(unsigned int outputIdentifierIndex, float x, float y, float z, float w)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_movf4;
    inst.mov.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.mov.inputDesc.y   = DRMTL_INPUT_DESC_CONSTF;
    inst.mov.inputDesc.z   = DRMTL_INPUT_DESC_CONSTF;
    inst.mov.inputDesc.w   = DRMTL_INPUT_DESC_CONSTF;
    inst.mov.inputX.valuef = x;
    inst.mov.inputY.valuef = y;
    inst.mov.inputZ.valuef = z;
    inst.mov.inputW.valuef = w;
    inst.mov.output        = outputIdentifierIndex;
 
    return inst;
}
 
 
drmtl_instruction drmtl_addf1_v1(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_addf1;
    inst.add.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.add.inputX.id     = inputIdentifierIndex;
    inst.add.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_addf1_c1(unsigned int outputIdentifierIndex, float x)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_addf1;
    inst.add.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.add.inputX.valuef = x;
    inst.add.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_addf2_v2(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_addf2;
    inst.add.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.add.inputDesc.y   = DRMTL_INPUT_DESC_VARY;
    inst.add.inputX.id     = inputIdentifierIndex;
    inst.add.inputY.id     = inputIdentifierIndex;
    inst.add.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_addf2_c2(unsigned int outputIdentifierIndex, float x, float y)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_addf2;
    inst.add.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.add.inputDesc.y   = DRMTL_INPUT_DESC_CONSTF;
    inst.add.inputX.valuef = x;
    inst.add.inputY.valuef = y;
    inst.add.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_addf3_v3(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_addf3;
    inst.add.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.add.inputDesc.y   = DRMTL_INPUT_DESC_VARY;
    inst.add.inputDesc.z   = DRMTL_INPUT_DESC_VARZ;
    inst.add.inputX.id     = inputIdentifierIndex;
    inst.add.inputY.id     = inputIdentifierIndex;
    inst.add.inputZ.id     = inputIdentifierIndex;
    inst.add.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_addf3_c3(unsigned int outputIdentifierIndex, float x, float y, float z)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_addf3;
    inst.add.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.add.inputDesc.y   = DRMTL_INPUT_DESC_CONSTF;
    inst.add.inputDesc.z   = DRMTL_INPUT_DESC_CONSTF;
    inst.add.inputX.valuef = x;
    inst.add.inputY.valuef = y;
    inst.add.inputZ.valuef = z;
    inst.add.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_addf4_v4(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_addf4;
    inst.add.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.add.inputDesc.y   = DRMTL_INPUT_DESC_VARY;
    inst.add.inputDesc.z   = DRMTL_INPUT_DESC_VARZ;
    inst.add.inputDesc.w   = DRMTL_INPUT_DESC_VARW;
    inst.add.inputX.id     = inputIdentifierIndex;
    inst.add.inputY.id     = inputIdentifierIndex;
    inst.add.inputZ.id     = inputIdentifierIndex;
    inst.add.inputW.id     = inputIdentifierIndex;
    inst.add.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_addf4_c4(unsigned int outputIdentifierIndex, float x, float y, float z, float w)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_addf4;
    inst.add.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.add.inputDesc.y   = DRMTL_INPUT_DESC_CONSTF;
    inst.add.inputDesc.z   = DRMTL_INPUT_DESC_CONSTF;
    inst.add.inputDesc.w   = DRMTL_INPUT_DESC_CONSTF;
    inst.add.inputX.valuef = x;
    inst.add.inputY.valuef = y;
    inst.add.inputZ.valuef = z;
    inst.add.inputW.valuef = w;
    inst.add.output        = outputIdentifierIndex;
 
    return inst;
}
 
 
drmtl_instruction drmtl_subf1_v1(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_subf1;
    inst.sub.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.sub.inputX.id     = inputIdentifierIndex;
    inst.sub.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_subf1_c1(unsigned int outputIdentifierIndex, float x)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_subf1;
    inst.sub.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.sub.inputX.valuef = x;
    inst.sub.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_subf2_v2(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_subf2;
    inst.sub.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.sub.inputDesc.y   = DRMTL_INPUT_DESC_VARY;
    inst.sub.inputX.id     = inputIdentifierIndex;
    inst.sub.inputY.id     = inputIdentifierIndex;
    inst.sub.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_subf2_c2(unsigned int outputIdentifierIndex, float x, float y)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_subf2;
    inst.sub.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.sub.inputDesc.y   = DRMTL_INPUT_DESC_CONSTF;
    inst.sub.inputX.valuef = x;
    inst.sub.inputY.valuef = y;
    inst.sub.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_subf3_v3(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_subf3;
    inst.sub.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.sub.inputDesc.y   = DRMTL_INPUT_DESC_VARY;
    inst.sub.inputDesc.z   = DRMTL_INPUT_DESC_VARZ;
    inst.sub.inputX.id     = inputIdentifierIndex;
    inst.sub.inputY.id     = inputIdentifierIndex;
    inst.sub.inputZ.id     = inputIdentifierIndex;
    inst.sub.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_subf3_c3(unsigned int outputIdentifierIndex, float x, float y, float z)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_subf3;
    inst.sub.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.sub.inputDesc.y   = DRMTL_INPUT_DESC_CONSTF;
    inst.sub.inputDesc.z   = DRMTL_INPUT_DESC_CONSTF;
    inst.sub.inputX.valuef = x;
    inst.sub.inputY.valuef = y;
    inst.sub.inputZ.valuef = z;
    inst.sub.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_subf4_v4(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_subf4;
    inst.sub.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.sub.inputDesc.y   = DRMTL_INPUT_DESC_VARY;
    inst.sub.inputDesc.z   = DRMTL_INPUT_DESC_VARZ;
    inst.sub.inputDesc.w   = DRMTL_INPUT_DESC_VARW;
    inst.sub.inputX.id     = inputIdentifierIndex;
    inst.sub.inputY.id     = inputIdentifierIndex;
    inst.sub.inputZ.id     = inputIdentifierIndex;
    inst.sub.inputW.id     = inputIdentifierIndex;
    inst.sub.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_subf4_c4(unsigned int outputIdentifierIndex, float x, float y, float z, float w)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_subf4;
    inst.sub.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.sub.inputDesc.y   = DRMTL_INPUT_DESC_CONSTF;
    inst.sub.inputDesc.z   = DRMTL_INPUT_DESC_CONSTF;
    inst.sub.inputDesc.w   = DRMTL_INPUT_DESC_CONSTF;
    inst.sub.inputX.valuef = x;
    inst.sub.inputY.valuef = y;
    inst.sub.inputZ.valuef = z;
    inst.sub.inputW.valuef = w;
    inst.sub.output        = outputIdentifierIndex;
 
    return inst;
}
 
 
drmtl_instruction drmtl_mulf1_v1(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_mulf1;
    inst.mul.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.mul.inputX.id     = inputIdentifierIndex;
    inst.mul.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_mulf1_c1(unsigned int outputIdentifierIndex, float x)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_mulf1;
    inst.mul.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.mul.inputX.valuef = x;
    inst.mul.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_mulf2_v2(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_mulf2;
    inst.mul.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.mul.inputDesc.y   = DRMTL_INPUT_DESC_VARY;
    inst.mul.inputX.id     = inputIdentifierIndex;
    inst.mul.inputY.id     = inputIdentifierIndex;
    inst.mul.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_mulf2_c2(unsigned int outputIdentifierIndex, float x, float y)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_mulf2;
    inst.mul.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.mul.inputDesc.y   = DRMTL_INPUT_DESC_CONSTF;
    inst.mul.inputX.valuef = x;
    inst.mul.inputY.valuef = y;
    inst.mul.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_mulf3_v3(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_mulf3;
    inst.mul.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.mul.inputDesc.y   = DRMTL_INPUT_DESC_VARY;
    inst.mul.inputDesc.z   = DRMTL_INPUT_DESC_VARZ;
    inst.mul.inputX.id     = inputIdentifierIndex;
    inst.mul.inputY.id     = inputIdentifierIndex;
    inst.mul.inputZ.id     = inputIdentifierIndex;
    inst.mul.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_mulf3_c3(unsigned int outputIdentifierIndex, float x, float y, float z)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_mulf3;
    inst.mul.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.mul.inputDesc.y   = DRMTL_INPUT_DESC_CONSTF;
    inst.mul.inputDesc.z   = DRMTL_INPUT_DESC_CONSTF;
    inst.mul.inputX.valuef = x;
    inst.mul.inputY.valuef = y;
    inst.mul.inputZ.valuef = z;
    inst.mul.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_mulf4_v4(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_mulf4;
    inst.mul.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.mul.inputDesc.y   = DRMTL_INPUT_DESC_VARY;
    inst.mul.inputDesc.z   = DRMTL_INPUT_DESC_VARZ;
    inst.mul.inputDesc.w   = DRMTL_INPUT_DESC_VARW;
    inst.mul.inputX.id     = inputIdentifierIndex;
    inst.mul.inputY.id     = inputIdentifierIndex;
    inst.mul.inputZ.id     = inputIdentifierIndex;
    inst.mul.inputW.id     = inputIdentifierIndex;
    inst.mul.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_mulf4_c4(unsigned int outputIdentifierIndex, float x, float y, float z, float w)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_mulf4;
    inst.mul.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.mul.inputDesc.y   = DRMTL_INPUT_DESC_CONSTF;
    inst.mul.inputDesc.z   = DRMTL_INPUT_DESC_CONSTF;
    inst.mul.inputDesc.w   = DRMTL_INPUT_DESC_CONSTF;
    inst.mul.inputX.valuef = x;
    inst.mul.inputY.valuef = y;
    inst.mul.inputZ.valuef = z;
    inst.mul.inputW.valuef = w;
    inst.mul.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_mulf4_v3v1(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndexXYZ, unsigned int inputIdentifierIndexW)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_mulf4;
    inst.mul.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.mul.inputDesc.y   = DRMTL_INPUT_DESC_VARY;
    inst.mul.inputDesc.z   = DRMTL_INPUT_DESC_VARZ;
    inst.mul.inputDesc.w   = DRMTL_INPUT_DESC_VARX;
    inst.mul.inputX.id     = inputIdentifierIndexXYZ;
    inst.mul.inputY.id     = inputIdentifierIndexXYZ;
    inst.mul.inputZ.id     = inputIdentifierIndexXYZ;
    inst.mul.inputW.id     = inputIdentifierIndexW;
    inst.mul.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_mulf4_v3c1(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex, float w)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_mulf4;
    inst.mul.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.mul.inputDesc.y   = DRMTL_INPUT_DESC_VARY;
    inst.mul.inputDesc.z   = DRMTL_INPUT_DESC_VARZ;
    inst.mul.inputDesc.w   = DRMTL_INPUT_DESC_CONSTF;
    inst.mul.inputX.id     = inputIdentifierIndex;
    inst.mul.inputY.id     = inputIdentifierIndex;
    inst.mul.inputZ.id     = inputIdentifierIndex;
    inst.mul.inputW.valuef = w;
    inst.mul.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_mulf4_v2c2(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex, float z, float w)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_mulf4;
    inst.mul.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.mul.inputDesc.y   = DRMTL_INPUT_DESC_VARY;
    inst.mul.inputDesc.z   = DRMTL_INPUT_DESC_CONSTF;
    inst.mul.inputDesc.w   = DRMTL_INPUT_DESC_CONSTF;
    inst.mul.inputX.id     = inputIdentifierIndex;
    inst.mul.inputY.id     = inputIdentifierIndex;
    inst.mul.inputZ.valuef = z;
    inst.mul.inputW.valuef = w;
    inst.mul.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_mulf4_v1c3(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex, float y, float z, float w)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_mulf4;
    inst.mul.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.mul.inputDesc.y   = DRMTL_INPUT_DESC_CONSTF;
    inst.mul.inputDesc.z   = DRMTL_INPUT_DESC_CONSTF;
    inst.mul.inputDesc.w   = DRMTL_INPUT_DESC_CONSTF;
    inst.mul.inputX.id     = inputIdentifierIndex;
    inst.mul.inputY.valuef = y;
    inst.mul.inputZ.valuef = z;
    inst.mul.inputW.valuef = w;
    inst.mul.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_mulf4_v1v1v1v1(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndexX, unsigned int inputIdentifierIndexY, unsigned int inputIdentifierIndexZ, unsigned int inputIdentifierIndexW)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_mulf4;
    inst.mul.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.mul.inputDesc.y   = DRMTL_INPUT_DESC_VARX;
    inst.mul.inputDesc.z   = DRMTL_INPUT_DESC_VARX;
    inst.mul.inputDesc.w   = DRMTL_INPUT_DESC_VARX;
    inst.mul.inputX.id     = inputIdentifierIndexX;
    inst.mul.inputY.id     = inputIdentifierIndexY;
    inst.mul.inputZ.id     = inputIdentifierIndexZ;
    inst.mul.inputW.id     = inputIdentifierIndexW;
    inst.mul.output        = outputIdentifierIndex;
 
    return inst;
}
 
 
drmtl_instruction drmtl_divf1_v1(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_divf1;
    inst.div.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.div.inputX.id     = inputIdentifierIndex;
    inst.div.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_divf1_c1(unsigned int outputIdentifierIndex, float x)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_divf1;
    inst.div.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.div.inputX.valuef = x;
    inst.div.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_divf2_v2(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_divf2;
    inst.div.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.div.inputDesc.y   = DRMTL_INPUT_DESC_VARY;
    inst.div.inputX.id     = inputIdentifierIndex;
    inst.div.inputY.id     = inputIdentifierIndex;
    inst.div.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_divf2_c2(unsigned int outputIdentifierIndex, float x, float y)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_divf2;
    inst.div.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.div.inputDesc.y   = DRMTL_INPUT_DESC_CONSTF;
    inst.div.inputX.valuef = x;
    inst.div.inputY.valuef = y;
    inst.div.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_divf3_v3(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_divf3;
    inst.div.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.div.inputDesc.y   = DRMTL_INPUT_DESC_VARY;
    inst.div.inputDesc.z   = DRMTL_INPUT_DESC_VARZ;
    inst.div.inputX.id     = inputIdentifierIndex;
    inst.div.inputY.id     = inputIdentifierIndex;
    inst.div.inputZ.id     = inputIdentifierIndex;
    inst.div.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_divf3_c3(unsigned int outputIdentifierIndex, float x, float y, float z)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_divf3;
    inst.div.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.div.inputDesc.y   = DRMTL_INPUT_DESC_CONSTF;
    inst.div.inputDesc.z   = DRMTL_INPUT_DESC_CONSTF;
    inst.div.inputX.valuef = x;
    inst.div.inputY.valuef = y;
    inst.div.inputZ.valuef = z;
    inst.div.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_divf4_v4(unsigned int outputIdentifierIndex, unsigned int inputIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_divf4;
    inst.div.inputDesc.x   = DRMTL_INPUT_DESC_VARX;
    inst.div.inputDesc.y   = DRMTL_INPUT_DESC_VARY;
    inst.div.inputDesc.z   = DRMTL_INPUT_DESC_VARZ;
    inst.div.inputDesc.w   = DRMTL_INPUT_DESC_VARW;
    inst.div.inputX.id     = inputIdentifierIndex;
    inst.div.inputY.id     = inputIdentifierIndex;
    inst.div.inputZ.id     = inputIdentifierIndex;
    inst.div.inputW.id     = inputIdentifierIndex;
    inst.div.output        = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_divf4_c4(unsigned int outputIdentifierIndex, float x, float y, float z, float w)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_divf4;
    inst.div.inputDesc.x   = DRMTL_INPUT_DESC_CONSTF;
    inst.div.inputDesc.y   = DRMTL_INPUT_DESC_CONSTF;
    inst.div.inputDesc.z   = DRMTL_INPUT_DESC_CONSTF;
    inst.div.inputDesc.w   = DRMTL_INPUT_DESC_CONSTF;
    inst.div.inputX.valuef = x;
    inst.div.inputY.valuef = y;
    inst.div.inputZ.valuef = z;
    inst.div.inputW.valuef = w;
    inst.div.output        = outputIdentifierIndex;
 
    return inst;
}
 
 
drmtl_instruction drmtl_tex2(unsigned int outputIdentifierIndex, unsigned int textureIdentifierIndex, unsigned int texcoordIdentifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_tex2;
    inst.tex.inputDesc.x = DRMTL_INPUT_DESC_VARX;
    inst.tex.inputDesc.y = DRMTL_INPUT_DESC_VARY;
    inst.tex.inputX.id   = texcoordIdentifierIndex;
    inst.tex.inputY.id   = texcoordIdentifierIndex;
    inst.tex.texture     = textureIdentifierIndex;
    inst.tex.output      = outputIdentifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_var(unsigned int identifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_var;
    inst.var.identifierIndex = identifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_retf1(unsigned int identifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_retf1;
    inst.ret.inputDesc.x = DRMTL_INPUT_DESC_VARX;
    inst.ret.inputX.id = identifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_retf2(unsigned int identifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_retf2;
    inst.ret.inputDesc.x = DRMTL_INPUT_DESC_VARX;
    inst.ret.inputDesc.y = DRMTL_INPUT_DESC_VARY;
    inst.ret.inputX.id = identifierIndex;
    inst.ret.inputY.id = identifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_retf3(unsigned int identifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_retf3;
    inst.ret.inputDesc.x = DRMTL_INPUT_DESC_VARX;
    inst.ret.inputDesc.y = DRMTL_INPUT_DESC_VARY;
    inst.ret.inputDesc.z = DRMTL_INPUT_DESC_VARZ;
    inst.ret.inputX.id = identifierIndex;
    inst.ret.inputY.id = identifierIndex;
    inst.ret.inputZ.id = identifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_retf4(unsigned int identifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_retf4;
    inst.ret.inputDesc.x = DRMTL_INPUT_DESC_VARX;
    inst.ret.inputDesc.y = DRMTL_INPUT_DESC_VARY;
    inst.ret.inputDesc.z = DRMTL_INPUT_DESC_VARZ;
    inst.ret.inputDesc.w = DRMTL_INPUT_DESC_VARW;
    inst.ret.inputX.id = identifierIndex;
    inst.ret.inputY.id = identifierIndex;
    inst.ret.inputZ.id = identifierIndex;
    inst.ret.inputW.id = identifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_retf1_c1(float x)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_retf1;
    inst.ret.inputDesc.x = DRMTL_INPUT_DESC_CONSTF;
    inst.ret.inputX.valuef = x;
 
    return inst;
}
 
drmtl_instruction drmtl_retf2_c2(float x, float y)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_retf2;
    inst.ret.inputDesc.x = DRMTL_INPUT_DESC_CONSTF;
    inst.ret.inputDesc.y = DRMTL_INPUT_DESC_CONSTF;
    inst.ret.inputX.valuef = x;
    inst.ret.inputY.valuef = y;
 
    return inst;
}
 
drmtl_instruction drmtl_retf3_c3(float x, float y, float z)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_retf3;
    inst.ret.inputDesc.x = DRMTL_INPUT_DESC_CONSTF;
    inst.ret.inputDesc.y = DRMTL_INPUT_DESC_CONSTF;
    inst.ret.inputDesc.z = DRMTL_INPUT_DESC_CONSTF;
    inst.ret.inputX.valuef = x;
    inst.ret.inputY.valuef = y;
    inst.ret.inputZ.valuef = z;
 
    return inst;
}
 
drmtl_instruction drmtl_retf4_c4(float x, float y, float z, float w)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_retf4;
    inst.ret.inputDesc.x = DRMTL_INPUT_DESC_CONSTF;
    inst.ret.inputDesc.y = DRMTL_INPUT_DESC_CONSTF;
    inst.ret.inputDesc.z = DRMTL_INPUT_DESC_CONSTF;
    inst.ret.inputDesc.w = DRMTL_INPUT_DESC_CONSTF;
    inst.ret.inputX.valuef = x;
    inst.ret.inputY.valuef = y;
    inst.ret.inputZ.valuef = z;
    inst.ret.inputW.valuef = w;
 
    return inst;
}
 
drmtl_instruction drmtl_reti1(unsigned int identifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_reti1;
    inst.ret.inputDesc.x = DRMTL_INPUT_DESC_VARX;
    inst.ret.inputX.id = identifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_reti2(unsigned int identifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_reti2;
    inst.ret.inputDesc.x = DRMTL_INPUT_DESC_VARX;
    inst.ret.inputDesc.y = DRMTL_INPUT_DESC_VARY;
    inst.ret.inputX.id = identifierIndex;
    inst.ret.inputY.id = identifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_reti3(unsigned int identifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_reti3;
    inst.ret.inputDesc.x = DRMTL_INPUT_DESC_VARX;
    inst.ret.inputDesc.y = DRMTL_INPUT_DESC_VARY;
    inst.ret.inputDesc.z = DRMTL_INPUT_DESC_VARZ;
    inst.ret.inputX.id = identifierIndex;
    inst.ret.inputY.id = identifierIndex;
    inst.ret.inputZ.id = identifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_reti4(unsigned int identifierIndex)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_reti4;
    inst.ret.inputDesc.x = DRMTL_INPUT_DESC_VARX;
    inst.ret.inputDesc.y = DRMTL_INPUT_DESC_VARY;
    inst.ret.inputDesc.z = DRMTL_INPUT_DESC_VARZ;
    inst.ret.inputDesc.w = DRMTL_INPUT_DESC_VARW;
    inst.ret.inputX.id = identifierIndex;
    inst.ret.inputY.id = identifierIndex;
    inst.ret.inputZ.id = identifierIndex;
    inst.ret.inputW.id = identifierIndex;
 
    return inst;
}
 
drmtl_instruction drmtl_reti1_c1(int x)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_reti1;
    inst.ret.inputDesc.x = DRMTL_INPUT_DESC_CONSTI;
    inst.ret.inputX.valuei = x;
 
    return inst;
}
 
drmtl_instruction drmtl_reti2_c2(int x, int y)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_reti2;
    inst.ret.inputDesc.x = DRMTL_INPUT_DESC_CONSTI;
    inst.ret.inputDesc.y = DRMTL_INPUT_DESC_CONSTI;
    inst.ret.inputX.valuei = x;
    inst.ret.inputY.valuei = y;
 
    return inst;
}
 
drmtl_instruction drmtl_reti3_c3(int x, int y, int z)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_reti3;
    inst.ret.inputDesc.x = DRMTL_INPUT_DESC_CONSTI;
    inst.ret.inputDesc.y = DRMTL_INPUT_DESC_CONSTI;
    inst.ret.inputDesc.z = DRMTL_INPUT_DESC_CONSTI;
    inst.ret.inputX.valuei = x;
    inst.ret.inputY.valuei = y;
    inst.ret.inputZ.valuei = z;
 
    return inst;
}
 
drmtl_instruction drmtl_reti4_c4(int x, int y, int z, int w)
{
    drmtl_instruction inst;
    inst.opcode = drmtl_opcode_reti4;
    inst.ret.inputDesc.x = DRMTL_INPUT_DESC_CONSTI;
    inst.ret.inputDesc.y = DRMTL_INPUT_DESC_CONSTI;
    inst.ret.inputDesc.z = DRMTL_INPUT_DESC_CONSTI;
    inst.ret.inputDesc.w = DRMTL_INPUT_DESC_CONSTI;
    inst.ret.inputX.valuei = x;
    inst.ret.inputY.valuei = y;
    inst.ret.inputZ.valuei = z;
    inst.ret.inputW.valuei = w;
 
    return inst;
}
 
 
 
drmtl_property drmtl_property_float(const char* name, float x)
{
    drmtl_property prop;
    prop.type = drmtl_type_float;
    drmtl_strcpy(prop.name, DRMTL_MAX_PROPERTY_NAME, name);
    prop.f1.x = x;
 
    return prop;
}
 
drmtl_property drmtl_property_float2(const char* name, float x, float y)
{
    drmtl_property prop;
    prop.type = drmtl_type_float2;
    drmtl_strcpy(prop.name, DRMTL_MAX_PROPERTY_NAME, name);
    prop.f2.x = x;
    prop.f2.y = y;
 
    return prop;
}
 
drmtl_property drmtl_property_float3(const char* name, float x, float y, float z)
{
    drmtl_property prop;
    prop.type = drmtl_type_float3;
    drmtl_strcpy(prop.name, DRMTL_MAX_PROPERTY_NAME, name);
    prop.f3.x = x;
    prop.f3.y = y;
    prop.f3.z = z;
 
    return prop;
}
 
drmtl_property drmtl_property_float4(const char* name, float x, float y, float z, float w)
{
    drmtl_property prop;
    prop.type = drmtl_type_float4;
    drmtl_strcpy(prop.name, DRMTL_MAX_PROPERTY_NAME, name);
    prop.f4.x = x;
    prop.f4.y = y;
    prop.f4.z = z;
    prop.f4.w = w;
 
    return prop;
}
 
drmtl_property drmtl_property_int(const char* name, int x)
{
    drmtl_property prop;
    prop.type = drmtl_type_int;
    drmtl_strcpy(prop.name, DRMTL_MAX_PROPERTY_NAME, name);
    prop.i1.x = x;
 
    return prop;
}
 
drmtl_property drmtl_property_int2(const char* name, int x, int y)
{
    drmtl_property prop;
    prop.type = drmtl_type_int2;
    drmtl_strcpy(prop.name, DRMTL_MAX_PROPERTY_NAME, name);
    prop.i2.x = x;
    prop.i2.y = y;
 
    return prop;
}
 
drmtl_property drmtl_property_int3(const char* name, int x, int y, int z)
{
    drmtl_property prop;
    prop.type = drmtl_type_int3;
    drmtl_strcpy(prop.name, DRMTL_MAX_PROPERTY_NAME, name);
    prop.i3.x = x;
    prop.i3.y = y;
    prop.i3.z = z;
 
    return prop;
}
 
drmtl_property drmtl_property_int4(const char* name, int x, int y, int z, int w)
{
    drmtl_property prop;
    prop.type = drmtl_type_int4;
    drmtl_strcpy(prop.name, DRMTL_MAX_PROPERTY_NAME, name);
    prop.i4.x = x;
    prop.i4.y = y;
    prop.i4.z = z;
    prop.i4.w = w;
 
    return prop;
}
 
drmtl_property drmtl_property_bool(const char* name, bool value)
{
    drmtl_property prop;
    prop.type = drmtl_type_bool;
    drmtl_strcpy(prop.name, DRMTL_MAX_PROPERTY_NAME, name);
    prop.b1.x = value;
 
    return prop;
}
 
 
 
 
 
//
// Compilers
//
 
#ifndef DRMTL_NO_MTL_COMPILER
typedef struct
{
    const char* pData;
 
    unsigned int dataSizeInBytes;
 
    const char* pDataCur;
 
    const char* pDataEnd;
 
 
    float diffuse[3];
 
    char diffuseMap[DRMTL_MAX_INPUT_PATH];
 
 
    float specular[3];
 
    char specularMap[DRMTL_MAX_INPUT_PATH];
 
 
    float specularExponent;
 
    char specularExponentMap[DRMTL_MAX_INPUT_PATH];
 
 
    float alpha;
 
    char alphaMap[DRMTL_MAX_INPUT_PATH];
 
 
} drmtl_wavefront;
 
bool drmtl_wavefront_is_whitespace(char c)
{
    return c == ' ' || c == '\t';
}
 
bool drmtl_wavefront_is_valid_digit(char c)
{
    return c >= '0' && c <= '9';
}
 
bool drmtl_wavefront_atof(const char* str, const char* strEnd, const char** strEndOut, float* valueOut)
{
    // Skip leading whitespace.
    while (str < strEnd && drmtl_wavefront_is_whitespace(*str))
    {
        str += 1;
    }
 
 
    // Check that we have a string after moving the whitespace.
    if (str < strEnd)
    {
        float sign  = 1.0f;
        float value = 0.0f;
 
        // Sign.
        if (*str == '-')
        {
            sign = -1.0f;
            str += 1;
        }
        else if (*str == '+')
        {
            sign = 1.0f;
            str += 1;
        }
 
 
        // Digits before the decimal point.
        while (str < strEnd && drmtl_wavefront_is_valid_digit(*str))
        {
            value = value * 10.0f + (*str - '0');
 
            str += 1;
        }
 
        // Digits after the decimal point.
        if (*str == '.')
        {
            float pow10 = 10.0f;
 
            str += 1;
            while (str < strEnd && drmtl_wavefront_is_valid_digit(*str))
            {
                value += (*str - '0') / pow10;
                pow10 *= 10.0f;
 
                str += 1;
            }
        }
 
 
        if (strEndOut != NULL)
        {
            *strEndOut = str;
        }
 
        if (valueOut != NULL)
        {
            *valueOut = sign * value;
        }
 
        return 1;
    }
    else
    {
        // Empty string. Leave output untouched and return 0.
        return 0;
    }
}
 
bool drmtl_wavefront_atof_3(const char* str, const char* strEnd, const char** strEndOut, float valueOut[3])
{
    float value[3];
    if (drmtl_wavefront_atof(str, strEnd, &str, &value[0]))
    {
        value[1] = value[0];
        value[2] = value[0];
 
        if (drmtl_wavefront_atof(str, strEnd, &str, &value[1]))
        {
            // We got two numbers which means we must have the third for this to be successful.
            if (!drmtl_wavefront_atof(str, strEnd, strEndOut, &value[2]))
            {
                // Failed to get the third number. We only found 2 which is not valid. Error.
                return 0;
            }
        }
 
 
        valueOut[0] = value[0];
        valueOut[1] = value[1];
        valueOut[2] = value[2];
 
        return 1;
    }
 
    return 0;
}
 
const char* drmtl_wavefront_find_end_of_line(const char* pDataCur, const char* pDataEnd)
{
    assert(pDataCur != NULL);
    assert(pDataEnd != NULL);
 
    while (pDataCur < pDataEnd)
    {
        if (pDataCur[0] == '\n')
        {
            return pDataCur;
        }
        else
        {
            if (pDataCur + 1 < pDataEnd)
            {
                if (pDataCur[0] == '\r' && pDataCur[1] == '\n')
                {
                    return pDataCur;
                }
            }
        }
 
        pDataCur += 1;
    }
 
    // If we get here it means we hit the end of the file before find a new-line character.
    return pDataEnd;
}
 
const char* drmtl_wavefront_find_next_line(const char* pDataCur, const char* pDataEnd)
{
    assert(pDataCur != NULL);
    assert(pDataEnd != NULL);
 
    pDataCur = drmtl_wavefront_find_end_of_line(pDataCur, pDataEnd);
    if (pDataCur != NULL)
    {
        if (pDataCur < pDataEnd)
        {
            if (pDataCur[0] == '\n')
            {
                return pDataCur + 1;
            }
            else
            {
                if (pDataCur + 1 < pDataEnd)
                {
                    if (pDataCur[0] == '\r' && pDataCur[1] == '\n')
                    {
                        return pDataCur + 2;
                    }
                }
            }
        }
    }
 
    return NULL;
}
 
const char* drmtl_wavefront_find_next_newmtl(const char* pDataCur, const char* pDataEnd)
{
    assert(pDataCur != NULL);
    assert(pDataEnd != NULL);
 
    while (pDataCur + 7 < pDataEnd)   // +7 for "newmtl" + a whitespace character.
    {
        if (pDataCur[0] == 'n' && pDataCur[1] == 'e' && pDataCur[2] == 'w' && pDataCur[3] == 'm' && pDataCur[4] == 't' && pDataCur[5] == 'l')
        {
            // We found "newmtl", however the next line must be whitespace.
            if (drmtl_wavefront_is_whitespace(pDataCur[6]))
            {
                // We found it.
                return pDataCur;
            }
        }
 
 
        const char* nextLineStart = drmtl_wavefront_find_next_line(pDataCur, pDataEnd);
        if (nextLineStart != NULL)
        {
            pDataCur = nextLineStart;
        }
        else
        {
            // Reached the end before finding "newmtl". Return null.
            return NULL;
        }
    }
 
    return NULL;
}
 
const char* drmtl_wavefront_find_next_nonwhitespace(const char* pDataCur, const char* pDataEnd)
{
    assert(pDataCur != NULL);
    assert(pDataEnd != NULL);
 
    while (pDataCur < pDataEnd)
    {
        if (!drmtl_wavefront_is_whitespace(pDataCur[0]))
        {
            return pDataCur;
        }
 
        pDataCur += 1;
    }
 
    return NULL;
}
 
 
bool drmtl_wavefront_parse_K(const char* pDataCur, const char* pDataEnd, float valueOut[3])
{
    assert(pDataCur != NULL);
    assert(pDataEnd != NULL);
 
    return drmtl_wavefront_atof_3(pDataCur, pDataEnd, &pDataEnd, valueOut);
}
 
bool drmtl_wavefront_parse_N(const char* pDataCur, const char* pDataEnd, float* valueOut)
{
    assert(pDataCur != NULL);
    assert(pDataEnd != NULL);
 
    return drmtl_wavefront_atof(pDataCur, pDataEnd, &pDataEnd, valueOut);
}
 
bool drmtl_wavefront_parse_map(const char* pDataCur, const char* pDataEnd, char* pathOut, unsigned int pathSizeInBytes)
{
    assert(pDataCur != NULL);
    assert(pDataEnd != NULL);
 
    // For now we're not supporting options, however support for that will be added later.
 
    const char* pPathStart = drmtl_wavefront_find_next_nonwhitespace(pDataCur, pDataEnd);
    if (pPathStart != NULL)
    {
        if (pPathStart < pDataEnd)
        {
            if (pPathStart[0] != '#')
            {
                // Find the last non-whitespace, making sure we don't include comments.
                pDataCur = pPathStart;
                const char* pPathEnd = pDataCur;
                while (pDataCur < pDataEnd && pDataCur[0] != '#')
                {
                    if (!drmtl_wavefront_is_whitespace(pDataCur[0]))
                    {
                        pPathEnd = pDataCur + 1;
                    }
 
                    pDataCur += 1;
                }
 
                assert(pPathStart < pPathEnd);
 
                ptrdiff_t pathLength = pPathEnd - pPathStart;
                if ((size_t)pathLength + 1 < pathSizeInBytes)
                {
                    memcpy(pathOut, pPathStart, (size_t)pathLength);
                    pathOut[pathLength] = '\0';
 
                    return 1;
                }
            }
        }
    }
 
    return 0;
}
 
 
bool drmtl_wavefront_seek_to_next_line(drmtl_wavefront* pWavefront)
{
    assert(pWavefront != NULL);
 
    const char* lineStart = drmtl_wavefront_find_next_line(pWavefront->pDataCur, pWavefront->pDataEnd);
    if (lineStart != NULL)
    {
        pWavefront->pDataCur = lineStart;
        return 1;
    }
 
    return 0;
}
 
bool drmtl_wavefront_seek_to_newmtl(drmtl_wavefront* pWavefront)
{
    assert(pWavefront != NULL);
 
    const char* usemtl = drmtl_wavefront_find_next_newmtl(pWavefront->pDataCur, pWavefront->pDataEnd);
    if (usemtl != NULL)
    {
        pWavefront->pDataCur = usemtl;
        return 1;
    }
 
    return 0;
}
 
bool drmtl_wavefront_parse(drmtl_wavefront* pWavefront)
{
    assert(pWavefront != NULL);
 
    if (drmtl_wavefront_seek_to_newmtl(pWavefront) && drmtl_wavefront_seek_to_next_line(pWavefront))
    {
        // Set the end of the material to the start of the second usemtl statement, if it exists.
        const char* usemtl2 = drmtl_wavefront_find_next_newmtl(pWavefront->pDataCur, pWavefront->pDataEnd);
        if (usemtl2 != NULL)
        {
            pWavefront->pDataEnd = usemtl2;
        }
 
 
        while (pWavefront->pDataCur < pWavefront->pDataEnd)
        {
            const char* lineCur = pWavefront->pDataCur;
            const char* lineEnd = drmtl_wavefront_find_end_of_line(lineCur, pWavefront->pDataEnd);
 
            lineCur = drmtl_wavefront_find_next_nonwhitespace(lineCur, lineEnd);
            if (lineCur != NULL && (lineCur + 2 < lineEnd))
            {
                if (lineCur[0] == 'K' && lineCur[1] == 'd' && drmtl_wavefront_is_whitespace(lineCur[2]))          // Diffuse colour
                {
                    lineCur += 3;
                    drmtl_wavefront_parse_K(lineCur, lineEnd, pWavefront->diffuse);
                }
                else if (lineCur[0] == 'K' && lineCur[1] == 's' && drmtl_wavefront_is_whitespace(lineCur[2]))     // Specular colour
                {
                    lineCur += 3;
                    drmtl_wavefront_parse_K(lineCur, lineEnd, pWavefront->specular);
                }
                else if (lineCur[0] == 'N' && lineCur[1] == 's' && drmtl_wavefront_is_whitespace(lineCur[2]))     // Specular exponent
                {
                    lineCur += 3;
                    drmtl_wavefront_parse_N(lineCur, lineEnd, &pWavefront->specularExponent);
                }
                else if (lineCur[0] == 'd' && drmtl_wavefront_is_whitespace(lineCur[1]))                          // Opacity/Alpha
                {
                    lineCur += 2;
                    drmtl_wavefront_parse_N(lineCur, lineEnd, &pWavefront->alpha);
                }
                else
                {
                    // Check for maps.
                    if (lineCur + 6 < lineEnd)
                    {
                        if (lineCur[0] == 'm' && lineCur[1] == 'a' && lineCur[2] == 'p' && lineCur[3] == '_')
                        {
                            if (lineCur[4] == 'K' && lineCur[5] == 'd' && drmtl_wavefront_is_whitespace(lineCur[6]))          // Diffuse map
                            {
                                lineCur += 7;
                                drmtl_wavefront_parse_map(lineCur, lineEnd, pWavefront->diffuseMap, DRMTL_MAX_INPUT_PATH);
                            }
                            else if (lineCur[4] == 'K' && lineCur[5] == 's' && drmtl_wavefront_is_whitespace(lineCur[6]))     // Specular map
                            {
                                lineCur += 7;
                                drmtl_wavefront_parse_map(lineCur, lineEnd, pWavefront->specularMap, DRMTL_MAX_INPUT_PATH);
                            }
                            else if (lineCur[4] == 'N' && lineCur[5] == 's' && drmtl_wavefront_is_whitespace(lineCur[6]))     // Specular exponent map
                            {
                                lineCur += 7;
                                drmtl_wavefront_parse_map(lineCur, lineEnd, pWavefront->specularExponentMap, DRMTL_MAX_INPUT_PATH);
                            }
                            else if (lineCur[4] == 'd' && drmtl_wavefront_is_whitespace(lineCur[5]))                          // Opacity/Alpha map
                            {
                                lineCur += 6;
                                drmtl_wavefront_parse_map(lineCur, lineEnd, pWavefront->alphaMap, DRMTL_MAX_INPUT_PATH);
                            }
                        }
                    }
                }
            }
 
 
            // Move to the end of the line.
            pWavefront->pDataCur = lineEnd;
 
            // Move to the start of the next line. If this fails it probably means we've reached the end of the data so we just break from the loop
            if (!drmtl_wavefront_seek_to_next_line(pWavefront))
            {
                break;
            }
        }
 
 
        return 1;
    }
 
    return 0;
}
 
bool drmtl_wavefront_compile(drmtl_material* pMaterial, drmtl_wavefront* pWavefront, const char* texcoordInputName)
{
    assert(pMaterial  != NULL);
    assert(pWavefront != NULL);
 
    unsigned int texCoordID;    // Private input for texture coordinates.
    unsigned int diffuseID;
    unsigned int specularID;
    unsigned int specularExponentID;
    unsigned int alphaID;
    unsigned int diffuseMapID = (unsigned int)-1;
    unsigned int specularMapID = (unsigned int)-1;
    unsigned int specularExponentMapID = (unsigned int)-1;
    unsigned int alphaMapID = (unsigned int)-1;
    unsigned int diffuseResultID = (unsigned int)-1;
    unsigned int specularResultID = (unsigned int)-1;
    unsigned int specularExponentResultID = (unsigned int)-1;
    unsigned int alphaResultID = (unsigned int)-1;
 
 
    // Identifiers.
    drmtl_appendidentifier(pMaterial, drmtl_identifier_float2(texcoordInputName), &texCoordID);
    drmtl_appendidentifier(pMaterial, drmtl_identifier_float4("DiffuseColor"), &diffuseID);
    drmtl_appendidentifier(pMaterial, drmtl_identifier_float3("SpecularColor"), &specularID);
    drmtl_appendidentifier(pMaterial, drmtl_identifier_float("SpecularExponent"), &specularExponentID);
    drmtl_appendidentifier(pMaterial, drmtl_identifier_float("Alpha"), &alphaID);
 
    if (pWavefront->diffuseMap[0] != '\0') {
        drmtl_appendidentifier(pMaterial, drmtl_identifier_tex2d("DiffuseMap"), &diffuseMapID);
        drmtl_appendidentifier(pMaterial, drmtl_identifier_float4("DiffuseResult"), &diffuseResultID);
    }
    if (pWavefront->specularMap[0] != '\0') {
        drmtl_appendidentifier(pMaterial, drmtl_identifier_tex2d("SpecularMap"), &specularMapID);
        drmtl_appendidentifier(pMaterial, drmtl_identifier_float4("SpecularResult"), &specularResultID);
    }
    if (pWavefront->specularExponentMap[0] != '\0') {
        drmtl_appendidentifier(pMaterial, drmtl_identifier_tex2d("SpecularExponentMap"), &specularExponentMapID);
        drmtl_appendidentifier(pMaterial, drmtl_identifier_float4("SpecularExponentResult"), &specularExponentResultID);
    }
    if (pWavefront->alphaMap[0] != '\0') {
        drmtl_appendidentifier(pMaterial, drmtl_identifier_tex2d("AlphaMap"), &alphaMapID);
        drmtl_appendidentifier(pMaterial, drmtl_identifier_float4("AlphaResult"), &alphaResultID);
    }
 
 
    // Inputs.
    drmtl_appendprivateinput(pMaterial, drmtl_input_float2(texCoordID, 0, 0));
    drmtl_appendpublicinput(pMaterial, drmtl_input_float4(diffuseID, pWavefront->diffuse[0], pWavefront->diffuse[1], pWavefront->diffuse[2], 1.0f));
    drmtl_appendpublicinput(pMaterial, drmtl_input_float3(specularID, pWavefront->specular[0], pWavefront->specular[1], pWavefront->specular[2]));
    drmtl_appendpublicinput(pMaterial, drmtl_input_float(specularExponentID, pWavefront->specularExponent));
    drmtl_appendpublicinput(pMaterial, drmtl_input_float(alphaID, pWavefront->alpha));
 
    if (pWavefront->diffuseMap[0] != '\0') {
        drmtl_appendpublicinput(pMaterial, drmtl_input_tex(diffuseMapID, pWavefront->diffuseMap));
    }
    if (pWavefront->specularMap[0] != '\0') {
        drmtl_appendpublicinput(pMaterial, drmtl_input_tex(specularMapID, pWavefront->specularMap));
    }
    if (pWavefront->specularExponentMap[0] != '\0') {
        drmtl_appendpublicinput(pMaterial, drmtl_input_tex(specularExponentMapID, pWavefront->specularExponentMap));
    }
    if (pWavefront->alphaMap[0] != '\0') {
        drmtl_appendpublicinput(pMaterial, drmtl_input_tex(alphaMapID, pWavefront->alphaMap));
    }
 
 
    // Channels.
    drmtl_appendchannel(pMaterial, drmtl_channel_float4("DiffuseChannel"));
    if (pWavefront->diffuseMap[0] != '\0') {
        drmtl_appendinstruction(pMaterial, drmtl_var(diffuseResultID));
        drmtl_appendinstruction(pMaterial, drmtl_tex2(diffuseResultID, diffuseMapID, texCoordID));
        drmtl_appendinstruction(pMaterial, drmtl_mulf4_v3c1(diffuseResultID, diffuseID, 1.0f));
        drmtl_appendinstruction(pMaterial, drmtl_retf4(diffuseResultID));
    } else {
        drmtl_appendinstruction(pMaterial, drmtl_retf4(diffuseID));
    }
 
    drmtl_appendchannel(pMaterial, drmtl_channel_float3("SpecularChannel"));
    if (pWavefront->specularMap[0] != '\0') {
        drmtl_appendinstruction(pMaterial, drmtl_var(specularResultID));
        drmtl_appendinstruction(pMaterial, drmtl_tex2(specularResultID, specularMapID, texCoordID));
        drmtl_appendinstruction(pMaterial, drmtl_mulf4_v3c1(specularResultID, specularID, 1.0f));
        drmtl_appendinstruction(pMaterial, drmtl_retf3(specularResultID));
    } else {
        drmtl_appendinstruction(pMaterial, drmtl_retf3(specularID));
    }
 
    drmtl_appendchannel(pMaterial, drmtl_channel_float("SpecularExponentChannel"));
    if (pWavefront->specularExponentMap[0] != '\0') {
        drmtl_appendinstruction(pMaterial, drmtl_var(specularExponentResultID));
        drmtl_appendinstruction(pMaterial, drmtl_tex2(specularResultID, specularMapID, texCoordID));
        drmtl_appendinstruction(pMaterial, drmtl_mulf4_v1c3(specularResultID, specularID, 1.0f, 1.0f, 1.0f));
        drmtl_appendinstruction(pMaterial, drmtl_retf1(specularResultID));
    } else {
        drmtl_appendinstruction(pMaterial, drmtl_retf1(specularExponentID));
    }
 
    drmtl_appendchannel(pMaterial, drmtl_channel_float("AlphaChannel"));
    if (pWavefront->alphaMap[0] != '\0') {
        drmtl_appendinstruction(pMaterial, drmtl_var(alphaResultID));
        drmtl_appendinstruction(pMaterial, drmtl_tex2(alphaResultID, alphaMapID, texCoordID));
        drmtl_appendinstruction(pMaterial, drmtl_mulf4_v1c3(alphaResultID, alphaID, 1.0f, 1.0f, 1.0f));
        drmtl_appendinstruction(pMaterial, drmtl_retf1(alphaResultID));
    } else {
        drmtl_appendinstruction(pMaterial, drmtl_retf1(alphaID));
    }
 
 
 
    // Properties.
    if (pWavefront->alphaMap[0] != '\0' || pWavefront->alpha < 1)
    {
        drmtl_appendproperty(pMaterial, drmtl_property_bool("IsTransparent", 1));
    }
 
    return 1;
}
 
 
bool drmtl_compile_wavefront_mtl(drmtl_material* pMaterial, const char* mtlData, size_t mtlDataSizeInBytes, const char* texcoordInputName)
{
    if (pMaterial != NULL && mtlData != NULL && mtlDataSizeInBytes > 0)
    {
        if (drmtl_init(pMaterial))
        {
            drmtl_wavefront wavefront;
            wavefront.pData                  = mtlData;
            wavefront.dataSizeInBytes        = mtlDataSizeInBytes;
            wavefront.pDataCur               = wavefront.pData;
            wavefront.pDataEnd               = wavefront.pData + wavefront.dataSizeInBytes;
            wavefront.diffuse[0]             = 1; wavefront.diffuse[1] = 1;  wavefront.diffuse[2] = 1;
            wavefront.diffuseMap[0]          = '\0';
            wavefront.specular[0]            = 1; wavefront.specular[1] = 1; wavefront.specular[2] = 1;
            wavefront.specularMap[0]         = '\0';
            wavefront.specularExponent       = 10;
            wavefront.specularExponentMap[0] = '\0';
            wavefront.alpha                  = 1;
            wavefront.alphaMap[0]            = '\0';
 
            if (drmtl_wavefront_parse(&wavefront))
            {
                if (drmtl_wavefront_compile(pMaterial, &wavefront, texcoordInputName))
                {
                    return 1;
                }
                else
                {
                    // Failed to compile.
                    drmtl_uninit(pMaterial);
                }
            }
            else
            {
                // Failed to parse the file.
                drmtl_uninit(pMaterial);
            }
        }
    }
 
    return 0;
}
#endif
 
 
 
 
//
// Code Generators
//
 
#ifndef DRMTL_NO_GLSL_CODEGEN
#include <stdio.h>
 
#if defined(__clang__)
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wswitch-enum"
    #pragma GCC diagnostic ignored "-Wcovered-switch-default"
    #pragma GCC diagnostic ignored "-Wused-but-marked-unused"   // This ie emitted for snprintf() for some reason. Need to investigate...
#endif
 
typedef struct
{
    char* pBufferOut;
 
    unsigned int bufferOutSizeInBytes;
 
    unsigned int runningLength;
 
 
    drmtl_material* pMaterial;
 
    drmtl_identifier* pIdentifiers;
 
    unsigned int identifierCount;
 
 
    unsigned int indentationLevel;
 
} drmtl_codegen_glsl;
 
bool drmtl_codegen_glsl_write(drmtl_codegen_glsl* pCodegen, const char* src)
{
    assert(pCodegen != NULL);
    assert(src      != NULL);
 
    if (pCodegen->pBufferOut != NULL)
    {
        unsigned int dstSizeInBytes = (pCodegen->bufferOutSizeInBytes - pCodegen->runningLength);
        while (dstSizeInBytes > 0 && src[0] != '\0')
        {
            pCodegen->pBufferOut[pCodegen->runningLength + 0] = src[0];
 
            pCodegen->runningLength += 1;
            src += 1;
            dstSizeInBytes -= 1;
        }
 
        if (dstSizeInBytes > 0)
        {
            // There's enough room for the null terminator which means there was enough room in the buffer. All good.
            pCodegen->pBufferOut[pCodegen->runningLength] = '\0';
            return 1;
        }
        else
        {
            // There's not enough room for the null terminator which means there was NOT enough room in the buffer. Error.
            return 0;
        }
    }
    else
    {
        // We're just measuring.
        pCodegen->runningLength += (unsigned int)strlen(src);
        return 1;
    }
}
 
bool drmtl_codegen_glsl_write_float(drmtl_codegen_glsl* pCodegen, float src)
{
    assert(pCodegen != NULL);
 
    char str[32];
    if (snprintf(str, 32, "%f", src) > 0)
    {
        return drmtl_codegen_glsl_write(pCodegen, str);
    }
    else
    {
        return 0;
    }
}
 
bool drmtl_codegen_glsl_write_int(drmtl_codegen_glsl* pCodegen, int src)
{
    assert(pCodegen != NULL);
 
    char str[32];
    if (snprintf(str, 32, "%d", src) > 0)
    {
        return drmtl_codegen_glsl_write(pCodegen, str);
    }
    else
    {
        return 0;
    }
}
 
bool drmtl_codegen_glsl_write_indentation(drmtl_codegen_glsl* pCodegen)
{
    assert(pCodegen != NULL);
 
    for (unsigned int i = 0; i < pCodegen->indentationLevel; ++i)
    {
        drmtl_codegen_glsl_write(pCodegen, " ");
    }
 
    return 1;
}
 
bool drmtl_codegen_glsl_write_type(drmtl_codegen_glsl* pCodegen, drmtl_type type)
{
    assert(pCodegen != NULL);
 
    switch (type)
    {
    case drmtl_type_float:
        {
            if (!drmtl_codegen_glsl_write(pCodegen, "float"))
            {
                return 0;
            }
 
            break;
        }
    case drmtl_type_float2:
        {
            if (!drmtl_codegen_glsl_write(pCodegen, "vec2"))
            {
                return 0;
            }
 
            break;
        }
    case drmtl_type_float3:
        {
            if (!drmtl_codegen_glsl_write(pCodegen, "vec3"))
            {
                return 0;
            }
 
            break;
        }
    case drmtl_type_float4:
        {
            if (!drmtl_codegen_glsl_write(pCodegen, "vec4"))
            {
                return 0;
            }
 
            break;
        }
 
    case drmtl_type_int:
        {
            if (!drmtl_codegen_glsl_write(pCodegen, "int"))
            {
                return 0;
            }
 
            break;
        }
    case drmtl_type_int2:
        {
            if (!drmtl_codegen_glsl_write(pCodegen, "ivec2"))
            {
                return 0;
            }
 
            break;
        }
    case drmtl_type_int3:
        {
            if (!drmtl_codegen_glsl_write(pCodegen, "ivec3"))
            {
                return 0;
            }
 
            break;
        }
    case drmtl_type_int4:
        {
            if (!drmtl_codegen_glsl_write(pCodegen, "ivec4"))
            {
                return 0;
            }
 
            break;
        }
 
    case drmtl_type_tex1d:
        {
            if (!drmtl_codegen_glsl_write(pCodegen, "sampler1D"))
            {
                return 0;
            }
 
            break;
        }
    case drmtl_type_tex2d:
        {
            if (!drmtl_codegen_glsl_write(pCodegen, "sampler2D"))
            {
                return 0;
            }
 
            break;
        }
    case drmtl_type_tex3d:
        {
            if (!drmtl_codegen_glsl_write(pCodegen, "sampler3D"))
            {
                return 0;
            }
 
            break;
        }
    case drmtl_type_texcube:
        {
            if (!drmtl_codegen_glsl_write(pCodegen, "samplerCube"))
            {
                return 0;
            }
 
            break;
        }
 
    default:
        {
            // Unsupported return type.
            return 0;
        }
    }
 
    return 1;
}
 
bool drmtl_codegen_glsl_write_instruction_input_scalar(drmtl_codegen_glsl* pCodegen, unsigned char descriptor, drmtl_instruction_input* pInput)
{
    assert(pCodegen != NULL);
    assert(pInput   != NULL);
 
    if (descriptor == DRMTL_INPUT_DESC_CONSTF)
    {
        // It's a constant float.
        return drmtl_codegen_glsl_write_float(pCodegen, pInput->valuef);
    }
    else if (descriptor == DRMTL_INPUT_DESC_CONSTI)
    {
        // It's a constant int.
        return drmtl_codegen_glsl_write_int(pCodegen, pInput->valuei);
    }
    else
    {
        // It's a variable.
        if (pInput->id < pCodegen->identifierCount)
        {
            drmtl_identifier* pIdentifier = pCodegen->pIdentifiers + pInput->id;
            assert(pIdentifier != NULL);
 
            if (pIdentifier->type == drmtl_type_float)
            {
                // The input variable is a float, so we don't want to use any selectors.
                return drmtl_codegen_glsl_write(pCodegen, pIdentifier->name);
            }
            else
            {
                if (drmtl_codegen_glsl_write(pCodegen, pIdentifier->name) && drmtl_codegen_glsl_write(pCodegen, "."))
                {
                    switch (descriptor)
                    {
                    case 0: return drmtl_codegen_glsl_write(pCodegen, "x");
                    case 1: return drmtl_codegen_glsl_write(pCodegen, "y");
                    case 2: return drmtl_codegen_glsl_write(pCodegen, "z");
                    case 3: return drmtl_codegen_glsl_write(pCodegen, "w");
                    default: return 0;
                    }
                }
            }
        }
    }
 
    return 0;
}
 
bool drmtl_codegen_glsl_write_instruction_input_initializer(drmtl_codegen_glsl* pCodegen, drmtl_type type, drmtl_instruction_input_descriptor inputDesc, drmtl_instruction_input* pInputs)
{
    assert(pCodegen != NULL);
    assert(pInputs  != NULL);
 
    switch (type)
    {
    case drmtl_type_float:
        {
            return drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.x, pInputs + 0);
        }
 
    case drmtl_type_float2:
        {
            if (drmtl_codegen_glsl_write(pCodegen, "vec2("))
            {
                if (drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.x, pInputs + 0) && drmtl_codegen_glsl_write(pCodegen, ", ") &&
                    drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.y, pInputs + 1))
                {
                    return drmtl_codegen_glsl_write(pCodegen, ")");
                }
            }
 
            break;
        }
 
    case drmtl_type_float3:
        {
            if (drmtl_codegen_glsl_write(pCodegen, "vec3("))
            {
                if (drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.x, pInputs + 0) && drmtl_codegen_glsl_write(pCodegen, ", ") &&
                    drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.y, pInputs + 1) && drmtl_codegen_glsl_write(pCodegen, ", ") &&
                    drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.z, pInputs + 2))
                {
                    return drmtl_codegen_glsl_write(pCodegen, ")");
                }
            }
 
            break;
        }
 
    case drmtl_type_float4:
        {
            if (drmtl_codegen_glsl_write(pCodegen, "vec4("))
            {
                if (drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.x, pInputs + 0) && drmtl_codegen_glsl_write(pCodegen, ", ") &&
                    drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.y, pInputs + 1) && drmtl_codegen_glsl_write(pCodegen, ", ") &&
                    drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.z, pInputs + 2) && drmtl_codegen_glsl_write(pCodegen, ", ") &&
                    drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.w, pInputs + 3))
                {
                    return drmtl_codegen_glsl_write(pCodegen, ")");
                }
            }
 
            break;
        }
 
 
    case drmtl_type_int:
        {
            return drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.x, pInputs + 0);
        }
 
    case drmtl_type_int2:
        {
            if (drmtl_codegen_glsl_write(pCodegen, "ivec2("))
            {
                if (drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.x, pInputs + 0) && drmtl_codegen_glsl_write(pCodegen, ", ") &&
                    drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.y, pInputs + 1))
                {
                    return drmtl_codegen_glsl_write(pCodegen, ")");
                }
            }
 
            break;
        }
 
    case drmtl_type_int3:
        {
            if (drmtl_codegen_glsl_write(pCodegen, "ivec3("))
            {
                if (drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.x, pInputs + 0) && drmtl_codegen_glsl_write(pCodegen, ", ") &&
                    drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.y, pInputs + 1) && drmtl_codegen_glsl_write(pCodegen, ", ") &&
                    drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.z, pInputs + 2))
                {
                    return drmtl_codegen_glsl_write(pCodegen, ")");
                }
            }
 
            break;
        }
 
    case drmtl_type_int4:
        {
            if (drmtl_codegen_glsl_write(pCodegen, "ivec4("))
            {
                if (drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.x, pInputs + 0) && drmtl_codegen_glsl_write(pCodegen, ", ") &&
                    drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.y, pInputs + 1) && drmtl_codegen_glsl_write(pCodegen, ", ") &&
                    drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.z, pInputs + 2) && drmtl_codegen_glsl_write(pCodegen, ", ") &&
                    drmtl_codegen_glsl_write_instruction_input_scalar(pCodegen, inputDesc.w, pInputs + 3))
                {
                    return drmtl_codegen_glsl_write(pCodegen, ")");
                }
            }
 
            break;
        }
 
 
    default:
        {
            // Unsupported return type.
            return 0;
        }
    }
 
    return 0;
}
 
 
bool drmtl_codegen_glsl_write_instruction_mov(drmtl_codegen_glsl* pCodegen, drmtl_instruction* pInstruction)
{
    assert(pCodegen     != NULL);
    assert(pInstruction != NULL);
 
    if (pInstruction->mov.output < pCodegen->identifierCount)
    {
        drmtl_identifier* pOutputIdentifier = pCodegen->pIdentifiers + pInstruction->mov.output;
        assert(pOutputIdentifier != NULL);
 
        if (drmtl_codegen_glsl_write(pCodegen, pOutputIdentifier->name) && drmtl_codegen_glsl_write(pCodegen, " = "))
        {
            drmtl_type type;
            switch (pInstruction->opcode)
            {
            case drmtl_opcode_movf1: type = drmtl_type_float;  break;
            case drmtl_opcode_movf2: type = drmtl_type_float2; break;
            case drmtl_opcode_movf3: type = drmtl_type_float3; break;
            case drmtl_opcode_movf4: type = drmtl_type_float4; break;
            case drmtl_opcode_movi1: type = drmtl_type_int;    break;
            case drmtl_opcode_movi2: type = drmtl_type_int2;   break;
            case drmtl_opcode_movi3: type = drmtl_type_int3;   break;
            case drmtl_opcode_movi4: type = drmtl_type_int4;   break;
            default: return 0;
            }
 
            return drmtl_codegen_glsl_write_instruction_input_initializer(pCodegen, type, pInstruction->mov.inputDesc, &pInstruction->mov.inputX) && drmtl_codegen_glsl_write(pCodegen, ";\n");
        }
    }
 
    return 0;
}
 
bool drmtl_codegen_glsl_write_instruction_add(drmtl_codegen_glsl* pCodegen, drmtl_instruction* pInstruction)
{
    assert(pCodegen     != NULL);
    assert(pInstruction != NULL);
 
    if (pInstruction->add.output < pCodegen->identifierCount)
    {
        drmtl_identifier* pOutputIdentifier = pCodegen->pIdentifiers + pInstruction->add.output;
        assert(pOutputIdentifier != NULL);
 
        if (drmtl_codegen_glsl_write(pCodegen, pOutputIdentifier->name) && drmtl_codegen_glsl_write(pCodegen, " += "))
        {
            drmtl_type type;
            switch (pInstruction->opcode)
            {
            case drmtl_opcode_addf1: type = drmtl_type_float;  break;
            case drmtl_opcode_addf2: type = drmtl_type_float2; break;
            case drmtl_opcode_addf3: type = drmtl_type_float3; break;
            case drmtl_opcode_addf4: type = drmtl_type_float4; break;
            case drmtl_opcode_addi1: type = drmtl_type_int;    break;
            case drmtl_opcode_addi2: type = drmtl_type_int2;   break;
            case drmtl_opcode_addi3: type = drmtl_type_int3;   break;
            case drmtl_opcode_addi4: type = drmtl_type_int4;   break;
            default: return 0;
            }
 
            return drmtl_codegen_glsl_write_instruction_input_initializer(pCodegen, type, pInstruction->add.inputDesc, &pInstruction->add.inputX) && drmtl_codegen_glsl_write(pCodegen, ";\n");
        }
    }
 
    return 0;
}
 
bool drmtl_codegen_glsl_write_instruction_sub(drmtl_codegen_glsl* pCodegen, drmtl_instruction* pInstruction)
{
    assert(pCodegen     != NULL);
    assert(pInstruction != NULL);
 
    if (pInstruction->add.output < pCodegen->identifierCount)
    {
        drmtl_identifier* pOutputIdentifier = pCodegen->pIdentifiers + pInstruction->sub.output;
        assert(pOutputIdentifier != NULL);
 
        if (drmtl_codegen_glsl_write(pCodegen, pOutputIdentifier->name) && drmtl_codegen_glsl_write(pCodegen, " -= "))
        {
            drmtl_type type;
            switch (pInstruction->opcode)
            {
            case drmtl_opcode_subf1: type = drmtl_type_float;  break;
            case drmtl_opcode_subf2: type = drmtl_type_float2; break;
            case drmtl_opcode_subf3: type = drmtl_type_float3; break;
            case drmtl_opcode_subf4: type = drmtl_type_float4; break;
            case drmtl_opcode_subi1: type = drmtl_type_int;    break;
            case drmtl_opcode_subi2: type = drmtl_type_int2;   break;
            case drmtl_opcode_subi3: type = drmtl_type_int3;   break;
            case drmtl_opcode_subi4: type = drmtl_type_int4;   break;
            default: return 0;
            }
 
            return drmtl_codegen_glsl_write_instruction_input_initializer(pCodegen, type, pInstruction->sub.inputDesc, &pInstruction->sub.inputX) && drmtl_codegen_glsl_write(pCodegen, ";\n");
        }
    }
 
    return 0;
}
 
bool drmtl_codegen_glsl_write_instruction_mul(drmtl_codegen_glsl* pCodegen, drmtl_instruction* pInstruction)
{
    assert(pCodegen     != NULL);
    assert(pInstruction != NULL);
 
    if (pInstruction->mul.output < pCodegen->identifierCount)
    {
        drmtl_identifier* pOutputIdentifier = pCodegen->pIdentifiers + pInstruction->mul.output;
        assert(pOutputIdentifier != NULL);
 
        if (drmtl_codegen_glsl_write(pCodegen, pOutputIdentifier->name) && drmtl_codegen_glsl_write(pCodegen, " *= "))
        {
            drmtl_type type;
            switch (pInstruction->opcode)
            {
            case drmtl_opcode_mulf1: type = drmtl_type_float;  break;
            case drmtl_opcode_mulf2: type = drmtl_type_float2; break;
            case drmtl_opcode_mulf3: type = drmtl_type_float3; break;
            case drmtl_opcode_mulf4: type = drmtl_type_float4; break;
            case drmtl_opcode_muli1: type = drmtl_type_int;    break;
            case drmtl_opcode_muli2: type = drmtl_type_int2;   break;
            case drmtl_opcode_muli3: type = drmtl_type_int3;   break;
            case drmtl_opcode_muli4: type = drmtl_type_int4;   break;
            default: return 0;
            }
 
            return drmtl_codegen_glsl_write_instruction_input_initializer(pCodegen, type, pInstruction->mul.inputDesc, &pInstruction->mul.inputX) && drmtl_codegen_glsl_write(pCodegen, ";\n");
        }
    }
 
    return 0;
}
 
bool drmtl_codegen_glsl_write_instruction_div(drmtl_codegen_glsl* pCodegen, drmtl_instruction* pInstruction)
{
    assert(pCodegen     != NULL);
    assert(pInstruction != NULL);
 
    if (pInstruction->div.output < pCodegen->identifierCount)
    {
        drmtl_identifier* pOutputIdentifier = pCodegen->pIdentifiers + pInstruction->div.output;
        assert(pOutputIdentifier != NULL);
 
        if (drmtl_codegen_glsl_write(pCodegen, pOutputIdentifier->name) && drmtl_codegen_glsl_write(pCodegen, " = "))
        {
            drmtl_type type;
            switch (pInstruction->opcode)
            {
            case drmtl_opcode_divf1: type = drmtl_type_float;  break;
            case drmtl_opcode_divf2: type = drmtl_type_float2; break;
            case drmtl_opcode_divf3: type = drmtl_type_float3; break;
            case drmtl_opcode_divf4: type = drmtl_type_float4; break;
            case drmtl_opcode_divi1: type = drmtl_type_int;    break;
            case drmtl_opcode_divi2: type = drmtl_type_int2;   break;
            case drmtl_opcode_divi3: type = drmtl_type_int3;   break;
            case drmtl_opcode_divi4: type = drmtl_type_int4;   break;
            default: return 0;
            }
 
            return drmtl_codegen_glsl_write_instruction_input_initializer(pCodegen, type, pInstruction->div.inputDesc, &pInstruction->div.inputX) && drmtl_codegen_glsl_write(pCodegen, ";\n");
        }
    }
 
    return 0;
}
 
bool drmtl_codegen_glsl_write_instruction_pow(drmtl_codegen_glsl* pCodegen, drmtl_instruction* pInstruction)
{
    assert(pCodegen     != NULL);
    assert(pInstruction != NULL);
 
    if (pInstruction->pow.output < pCodegen->identifierCount)
    {
        drmtl_identifier* pOutputIdentifier = pCodegen->pIdentifiers + pInstruction->pow.output;
        assert(pOutputIdentifier != NULL);
 
        if (drmtl_codegen_glsl_write(pCodegen, pOutputIdentifier->name) && drmtl_codegen_glsl_write(pCodegen, " = pow(") && drmtl_codegen_glsl_write(pCodegen, pOutputIdentifier->name) && drmtl_codegen_glsl_write(pCodegen, ", "))
        {
            drmtl_type type;
            switch (pInstruction->opcode)
            {
            case drmtl_opcode_powf1: type = drmtl_type_float;  break;
            case drmtl_opcode_powf2: type = drmtl_type_float2; break;
            case drmtl_opcode_powf3: type = drmtl_type_float3; break;
            case drmtl_opcode_powf4: type = drmtl_type_float4; break;
            case drmtl_opcode_powi1: type = drmtl_type_int;    break;
            case drmtl_opcode_powi2: type = drmtl_type_int2;   break;
            case drmtl_opcode_powi3: type = drmtl_type_int3;   break;
            case drmtl_opcode_powi4: type = drmtl_type_int4;   break;
            default: return 0;
            }
 
            return drmtl_codegen_glsl_write_instruction_input_initializer(pCodegen, type, pInstruction->pow.inputDesc, &pInstruction->pow.inputX) && drmtl_codegen_glsl_write(pCodegen, ");\n");
        }
    }
 
    return 0;
}
 
bool drmtl_codegen_glsl_write_instruction_tex(drmtl_codegen_glsl* pCodegen, drmtl_instruction* pInstruction)
{
    assert(pCodegen     != NULL);
    assert(pInstruction != NULL);
 
    if (pInstruction->tex.output < pCodegen->identifierCount && pInstruction->tex.texture < pCodegen->identifierCount)
    {
        drmtl_identifier* pOutputIdentifier = pCodegen->pIdentifiers + pInstruction->tex.output;
        assert(pOutputIdentifier != NULL);
 
        drmtl_identifier* pTextureIdentifier = pCodegen->pIdentifiers + pInstruction->tex.texture;
        assert(pTextureIdentifier != NULL);
 
        if (drmtl_codegen_glsl_write(pCodegen, pOutputIdentifier->name) && drmtl_codegen_glsl_write(pCodegen, " = "))
        {
            drmtl_type type;
            switch (pInstruction->opcode)
            {
            case drmtl_opcode_tex1:
            {
                type = drmtl_type_float;
                if (!drmtl_codegen_glsl_write(pCodegen, "texture1D("))
                {
                    return 0;
                }
 
                break;
            }
 
            case drmtl_opcode_tex2:
            {
                type = drmtl_type_float2;
                if (!drmtl_codegen_glsl_write(pCodegen, "texture2D("))
                {
                    return 0;
                }
 
                break;
            }
 
            case drmtl_opcode_tex3:
            {
                type = drmtl_type_float3;
                if (!drmtl_codegen_glsl_write(pCodegen, "texture3D("))
                {
                    return 0;
                }
 
                break;
            }
 
            case drmtl_opcode_texcube:
            {
                type = drmtl_type_float3;
                if (!drmtl_codegen_glsl_write(pCodegen, "textureCube("))
                {
                    return 0;
                }
 
                break;
            }
 
            default: return 0;
            }
 
            return
                drmtl_codegen_glsl_write(pCodegen, pTextureIdentifier->name) &&
                drmtl_codegen_glsl_write(pCodegen, ", ") &&
                drmtl_codegen_glsl_write_instruction_input_initializer(pCodegen, type, pInstruction->tex.inputDesc, &pInstruction->tex.inputX) &&
                drmtl_codegen_glsl_write(pCodegen, ");\n");
        }
    }
 
    return 0;
}
 
bool drmtl_codegen_glsl_write_instruction_var(drmtl_codegen_glsl* pCodegen, drmtl_instruction* pInstruction)
{
    assert(pCodegen     != NULL);
    assert(pInstruction != NULL);
 
    if (pInstruction->var.identifierIndex < pCodegen->identifierCount)
    {
        drmtl_identifier* pIdentifier = pCodegen->pIdentifiers + pInstruction->var.identifierIndex;
        assert(pIdentifier != NULL);
 
        return drmtl_codegen_glsl_write_type(pCodegen, pIdentifier->type) && drmtl_codegen_glsl_write(pCodegen, " ") && drmtl_codegen_glsl_write(pCodegen, pIdentifier->name) && drmtl_codegen_glsl_write(pCodegen, ";\n");
    }
 
    return 0;
}
 
bool drmtl_codegen_glsl_write_instruction_ret(drmtl_codegen_glsl* pCodegen, drmtl_instruction* pInstruction)
{
    assert(pCodegen     != NULL);
    assert(pInstruction != NULL);
 
    if (drmtl_codegen_glsl_write(pCodegen, "return "))
    {
        drmtl_type type;
        switch (pInstruction->opcode)
        {
        case drmtl_opcode_retf1: type = drmtl_type_float;  break;
        case drmtl_opcode_retf2: type = drmtl_type_float2; break;
        case drmtl_opcode_retf3: type = drmtl_type_float3; break;
        case drmtl_opcode_retf4: type = drmtl_type_float4; break;
        case drmtl_opcode_reti1: type = drmtl_type_int;    break;
        case drmtl_opcode_reti2: type = drmtl_type_int2;   break;
        case drmtl_opcode_reti3: type = drmtl_type_int3;   break;
        case drmtl_opcode_reti4: type = drmtl_type_int4;   break;
        default: return 0;
        }
 
        return drmtl_codegen_glsl_write_instruction_input_initializer(pCodegen, type, pInstruction->ret.inputDesc, &pInstruction->ret.inputX) && drmtl_codegen_glsl_write(pCodegen, ";\n");
    }
 
    return 0;
}
 
bool drmtl_codegen_glsl_write_instruction(drmtl_codegen_glsl* pCodegen, drmtl_instruction* pInstruction)
{
    assert(pCodegen     != NULL);
    assert(pInstruction != NULL);
 
    if (drmtl_codegen_glsl_write_indentation(pCodegen))
    {
        switch (pInstruction->opcode)
        {
        case drmtl_opcode_movf1:
        case drmtl_opcode_movf2:
        case drmtl_opcode_movf3:
        case drmtl_opcode_movf4:
        case drmtl_opcode_movi1:
        case drmtl_opcode_movi2:
        case drmtl_opcode_movi3:
        case drmtl_opcode_movi4:
            {
                return drmtl_codegen_glsl_write_instruction_mov(pCodegen, pInstruction);
            }
 
 
        case drmtl_opcode_addf1:
        case drmtl_opcode_addf2:
        case drmtl_opcode_addf3:
        case drmtl_opcode_addf4:
        case drmtl_opcode_addi1:
        case drmtl_opcode_addi2:
        case drmtl_opcode_addi3:
        case drmtl_opcode_addi4:
            {
                return drmtl_codegen_glsl_write_instruction_add(pCodegen, pInstruction);
            }
 
        case drmtl_opcode_subf1:
        case drmtl_opcode_subf2:
        case drmtl_opcode_subf3:
        case drmtl_opcode_subf4:
        case drmtl_opcode_subi1:
        case drmtl_opcode_subi2:
        case drmtl_opcode_subi3:
        case drmtl_opcode_subi4:
            {
                return drmtl_codegen_glsl_write_instruction_sub(pCodegen, pInstruction);
            }
 
        case drmtl_opcode_mulf1:
        case drmtl_opcode_mulf2:
        case drmtl_opcode_mulf3:
        case drmtl_opcode_mulf4:
        case drmtl_opcode_muli1:
        case drmtl_opcode_muli2:
        case drmtl_opcode_muli3:
        case drmtl_opcode_muli4:
            {
                return drmtl_codegen_glsl_write_instruction_mul(pCodegen, pInstruction);
            }
 
        case drmtl_opcode_divf1:
        case drmtl_opcode_divf2:
        case drmtl_opcode_divf3:
        case drmtl_opcode_divf4:
        case drmtl_opcode_divi1:
        case drmtl_opcode_divi2:
        case drmtl_opcode_divi3:
        case drmtl_opcode_divi4:
            {
                return drmtl_codegen_glsl_write_instruction_div(pCodegen, pInstruction);
            }
 
        case drmtl_opcode_powf1:
        case drmtl_opcode_powf2:
        case drmtl_opcode_powf3:
        case drmtl_opcode_powf4:
        case drmtl_opcode_powi1:
        case drmtl_opcode_powi2:
        case drmtl_opcode_powi3:
        case drmtl_opcode_powi4:
            {
                return drmtl_codegen_glsl_write_instruction_pow(pCodegen, pInstruction);
            }
 
        case drmtl_opcode_tex1:
        case drmtl_opcode_tex2:
        case drmtl_opcode_tex3:
        case drmtl_opcode_texcube:
            {
                return drmtl_codegen_glsl_write_instruction_tex(pCodegen, pInstruction);
            }
 
 
        case drmtl_opcode_var:
            {
                return drmtl_codegen_glsl_write_instruction_var(pCodegen, pInstruction);
            }
 
        case drmtl_opcode_retf1:
        case drmtl_opcode_retf2:
        case drmtl_opcode_retf3:
        case drmtl_opcode_retf4:
        case drmtl_opcode_reti1:
        case drmtl_opcode_reti2:
        case drmtl_opcode_reti3:
        case drmtl_opcode_reti4:
            {
                return drmtl_codegen_glsl_write_instruction_ret(pCodegen, pInstruction);
            }
 
 
        default:
            {
                // Unknown or unsupported opcode.
                break;
            }
        }
    }
 
    return 0;
}
 
bool drmtl_codegen_glsl_write_instructions(drmtl_codegen_glsl* pCodegen, drmtl_instruction* pInstructions, unsigned int instructionCount)
{
    assert(pCodegen      != NULL);
    assert(pInstructions != NULL);
 
    for (unsigned int iInstruction = 0; iInstruction < instructionCount; ++iInstruction)
    {
        drmtl_instruction* pInstruction = pInstructions + iInstruction;
        assert(pInstruction != NULL);
 
        if (!drmtl_codegen_glsl_write_instruction(pCodegen, pInstruction))
        {
            return 0;
        }
    }
 
    return 1;
}
 
bool drmtl_codegen_glsl_channel_function_begin(drmtl_codegen_glsl* pCodegen, drmtl_channel_header* pChannelHeader)
{
    assert(pCodegen       != NULL);
    assert(pChannelHeader != NULL);
 
    // <type> <name> {\n
    bool result =
        drmtl_codegen_glsl_write_type(pCodegen, pChannelHeader->channel.type) &&
        drmtl_codegen_glsl_write(pCodegen, " ") &&
        drmtl_codegen_glsl_write(pCodegen, pChannelHeader->channel.name) &&
        drmtl_codegen_glsl_write(pCodegen, "() {\n");
    if (result)
    {
        pCodegen->indentationLevel += 4;
    }
 
    return result;
}
 
bool drmtl_codegen_glsl_channel_function_close(drmtl_codegen_glsl* pCodegen)
{
    assert(pCodegen != NULL);
 
    if (pCodegen->indentationLevel > 4) {
        pCodegen->indentationLevel -= 4;
    } else {
        pCodegen->indentationLevel = 0;
    }
 
    return drmtl_codegen_glsl_write(pCodegen, "}\n");
}
 
bool drmtl_codegen_glsl_channel(drmtl_material* pMaterial, const char* channelName, char* codeOut, size_t codeOutSizeInBytes, size_t* pBytesWrittenOut)
{
    if (pMaterial != NULL)
    {
        drmtl_header* pHeader = drmtl_getheader(pMaterial);
        if (pHeader != NULL)
        {
            drmtl_channel_header* pChannelHeader = drmtl_getchannelheaderbyname(pMaterial, channelName);
            if (pChannelHeader != NULL)
            {
                drmtl_codegen_glsl codegen;
                codegen.pBufferOut           = codeOut;
                codegen.bufferOutSizeInBytes = codeOutSizeInBytes;
                codegen.runningLength        = 0;
                codegen.pMaterial            = pMaterial;
                codegen.pIdentifiers         = drmtl_getidentifiers(pMaterial);
                codegen.identifierCount      = drmtl_getidentifiercount(pMaterial);
                codegen.indentationLevel     = 0;
 
                if (drmtl_codegen_glsl_channel_function_begin(&codegen, pChannelHeader))
                {
                    drmtl_instruction* pInstructions = (drmtl_instruction*)(pChannelHeader + 1);
                    assert(pInstructions != NULL);
 
                    if (drmtl_codegen_glsl_write_instructions(&codegen, pInstructions, pChannelHeader->instructionCount))
                    {
                        bool result = drmtl_codegen_glsl_channel_function_close(&codegen);
                        if (result)
                        {
                            if (pBytesWrittenOut != NULL)
                            {
                                *pBytesWrittenOut = codegen.runningLength + 1;
                            }
                        }
 
                        return result;
                    }
                }
            }
        }
    }
 
    return 0;
}
 
 
 
bool drmtl_codegen_glsl_uniform(drmtl_codegen_glsl* pCodegen, drmtl_input* pInput)
{
    assert(pCodegen != NULL);
    assert(pInput   != NULL);
 
    if (pInput->identifierIndex < pCodegen->identifierCount)
    {
        drmtl_identifier* pIdentifier = pCodegen->pIdentifiers + pInput->identifierIndex;
        assert(pIdentifier != NULL);
 
        // uniform <type> <name>;
        return
            drmtl_codegen_glsl_write(pCodegen, "uniform ") &&
            drmtl_codegen_glsl_write_type(pCodegen, pIdentifier->type) &&
            drmtl_codegen_glsl_write(pCodegen, " ") &&
            drmtl_codegen_glsl_write(pCodegen, pIdentifier->name) &&
            drmtl_codegen_glsl_write(pCodegen, ";\n");
    }
 
    return 0;
}
 
bool drmtl_codegen_glsl_uniforms(drmtl_material* pMaterial, char* codeOut, size_t codeOutSizeInBytes, size_t* pBytesWritteOut)
{
    if (pMaterial != NULL)
    {
        drmtl_codegen_glsl codegen;
        codegen.pBufferOut           = codeOut;
        codegen.bufferOutSizeInBytes = codeOutSizeInBytes;
        codegen.runningLength        = 0;
        codegen.pMaterial            = pMaterial;
        codegen.pIdentifiers         = drmtl_getidentifiers(pMaterial);
        codegen.identifierCount      = drmtl_getidentifiercount(pMaterial);
        codegen.indentationLevel     = 0;
 
 
        unsigned int inputCount = drmtl_getpublicinputcount(pMaterial);
        if (inputCount > 0)
        {
            for (unsigned int iInput = 0; iInput < inputCount; ++iInput)
            {
                drmtl_input* pInput = drmtl_getpublicinputbyindex(pMaterial, iInput);
                assert(pInput != NULL);
 
                if (!drmtl_codegen_glsl_uniform(&codegen, pInput))
                {
                    // There was an error writing one of the uniforms. Return false.
                    return 0;
                }
            }
        }
        else
        {
            // No inputs. Just write an empty string.
            drmtl_codegen_glsl_write(&codegen, "");
        }
 
        if (pBytesWritteOut != NULL)
        {
            *pBytesWritteOut = codegen.runningLength + 1;
        }
 
        return 1;
    }
 
    return 0;
}
 
#if defined(__clang__)
    #pragma GCC diagnostic pop
#endif
#endif
 
#if defined(__clang__)
    #pragma GCC diagnostic pop
#endif
#endif
 
/*
This is free and unencumbered software released into the public domain.
 
Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any
means.
 
In jurisdictions that recognize copyright laws, the author or authors
of this software dedicate any and all copyright interest in the
software to the public domain. We make this dedication for the benefit
of the public at large and to the detriment of our heirs and
successors. We intend this dedication to be an overt act of
relinquishment in perpetuity of all present and future rights to this
software under copyright law.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
 
For more information, please refer to <http://unlicense.org/>
*/