esLuma.h

GLint projection_id;
GLint modelview_id;
GLint position_id;
GLint normal_id;
GLint color_id;
GLint lightpos_id;
GLint ambient_id;
GLint saturate_id;
GLint specular_id;
GLint specpower_id;
GLint hsv_id;
GLint viewdist_id;
GLint opacity_id;
GLint lightness_id;
typedef struct{float x,y,z,w;} vec;
typedef struct {float m[4][4];} mat;
mat projection, view, model, modelview;
#define updateModelView() ; mMul(&modelview,&model,&view);glUniformMatrix4fv(modelview_id,1,GL_FALSE,(float*)&modelview.m[0][0]);
#define toView() ; glUniformMatrix4fv(modelview_id,1,GL_FALSE,(float*)&view.m[0][0]);
#define toModelView() ; glUniformMatrix4fv(modelview_id,1,GL_FALSE,(float*)&modelview.m[0][0]);
typedef struct
{
    GLuint vid;
    GLuint iid;
    GLuint cid;
    GLuint nid;
#ifdef MAX_MODELS
    GLuint itp;
    GLuint ni;
    GLuint nv;
    GLfloat *vertices, *normals;
    GLubyte *colors;
    vec pos;
    GLfloat rad;
    GLfloat rsq;
#endif
} ESModel;
GLuint esRand(const GLuint min, const GLuint max);
GLfloat esRandFloat(const GLfloat min, const GLfloat max);
void esBind(const GLenum target, GLuint* buffer, const void* data, const GLsizeiptr datalen, const GLenum usage);
void esRebind(const GLenum target, GLuint* buffer, const void* data, const GLsizeiptr datalen, const GLenum usage);
void shadeFullbrightSolid(GLint* position, GLint* projection, GLint* modelview, GLint* color, GLint* lightness, GLint* opacity);
void shadeLambertSolid(GLint* position, GLint* projection, GLint* modelview, GLint* lightpos, GLint* normal, GLint* color, GLint* ambient, GLint* saturate, GLint* opacity);
void shadeFullbright(GLint* position, GLint* projection, GLint* modelview, GLint* color, GLint* lightness, GLint* opacity);
void shadeLambert(GLint* position, GLint* projection, GLint* modelview, GLint* lightpos, GLint* normal, GLint* color, GLint* ambient, GLint* saturate, GLint* opacity);
void shadePhong(GLint* position, GLint* iprojection, GLint* imodelview, GLint* lightpos, GLint* normal, GLint* color, GLint* ambient, GLint* specular, GLint* specpower, GLint* hsv, GLint* viewdist, GLint* opacity);
GLuint debugShader(GLuint shader_program);
void makeAllShaders();
void makeFullbrightSolid();
void makeLambertSolid();
void makeFullbright();
void makeLambert();
void makePhong();
#define PI 3.14159265359f
#define x2PI 6.28318530718f
#define d2PI 1.57079632679f
#define DEGREE 57.2957795131f
#define RADIAN 0.01745329251f
#define RAD2DEG DEGREE
#define DEG2RAD RADIAN
#define FLOAT_MAX 9223372036854775807.f
static inline float randf();
static inline float randfc();
float randfn();
static inline float fRandFloat(const float min, const float max);
static inline int fRand(const float min, const float max);
int vec_ftoi(float f);
float smoothstep(float x){return x*x*(3.f-2.f*x);}
void vRuv(vec* v);
void vRuvN(vec* v);
void vRuvBT(vec* v);
void vRuvTA(vec* v);
void vRuvTD(vec* v);
void vCross(vec* r, const vec v1, const vec v2);
float vDot(const vec v1, const vec v2);
float vSum(const vec v);
float vSumAbs(const vec v);
void vReflect(vec* r, const vec v, const vec n);
int vEqualTol(const vec a, const vec b, const float tol);
int vEqualInt(const vec a, const vec b);
void vMin(vec* r, const vec v1, const vec v2);
void vMax(vec* r, const vec v1, const vec v2);
void vNorm(vec* v);
float vDist(const vec v1, const vec v2);
float vDistSq(const vec a, const vec b);
float vDistMh(const vec a, const vec b);
float vDistLa(const vec a, const vec b);
float vMod(const vec v);
float vMag(const vec v);
void vInv(vec* v);
void vCopy(vec* r, const vec v);
void vDir(vec* r, const vec v1, const vec v2);
void vRotX(vec* v, const float radians);
void vRotY(vec* v, const float radians);
void vRotZ(vec* v, const float radians);
void vAdd(vec* r, const vec v1, const vec v2);
void vSub(vec* r, const vec v1, const vec v2);
void vDiv(vec* r, const vec numerator, const vec denominator);
void vMul(vec* r, const vec v1, const vec v2);
void vAddS(vec* r, const vec v1, const float v2);
void vSubS(vec* r, const vec v1, const float v2);
void vDivS(vec* r, const vec v1, const float v2);
void vMulS(vec* r, const vec v1, const float v2);
void mIdent(mat *m);
void mCopy(mat *r, const mat *v);
void mMul(mat *r, const mat *a, const mat *b);
void mMulP(vec *r, const mat *a, const float x, const float y, const float z);
void mMulV(vec *r, const mat *a, const vec v);
void mScale(mat *r, const float x, const float y, const float z);
void mScale1(mat *r, const float s);
void mTranslate(mat *r, const float x, const float y, const float z);
void mRotate(mat *r, const float radians, float x, float y, float z);
void mRotX(mat *r, const float radians);
void mRotY(mat *r, const float radians);
void mRotZ(mat *r, const float radians);
void mAngleAxisRotate(mat *r, const mat view, const float xrot, const float yrot, const float zrot);
void mFrustum(mat *r, const float left, const float right, const float bottom, const float top, const float nearZ, const float farZ);
void mPerspective(mat *r, const float fovy, const float aspect, const float nearZ, const float farZ);
void mOrtho(mat *r, const float left, const float right, const float bottom, const float top, const float nearZ, const float farZ);
void mLookAt(mat *r, const vec origin, const vec unit_dir);
void mInvert(float *dst, const float *mat);
void mTranspose(mat *r, const mat *m);
void mSetViewDir(mat *r, const vec dir_norm);
void mGetViewDir(vec *r, const mat matrix);
void mGetViewX(vec *r, const mat matrix);
void mGetViewY(vec *r, const mat matrix);
void mGetViewZ(vec *r, const mat matrix);
void mSetDir(mat *r, const vec dir_norm);
void mGetDirX(vec *r, const mat matrix);
void mGetDirY(vec *r, const mat matrix);
void mGetDirZ(vec *r, const mat matrix);
void mGetPos(vec *r, const mat matrix);
void mSetPos(mat *r, const vec pos);
void mDump(const mat matrix);
float mGetRotX(const mat *m);
float mGetRotY(const mat *m);
float mGetRotZ(const mat *m);
void mSetRotX(mat *r, const float radians);
void mSetRotY(mat *r, const float radians);
void mSetRotZ(mat *r, const float radians);
GLuint esRand(const GLuint min, const GLuint max){return (rand()%(max+1-min))+min;}
GLfloat esRandFloat(const GLfloat min, const GLfloat max)
{
    static GLfloat rrndmax = 1.f/(GLfloat)RAND_MAX;
    return (((GLfloat)rand()) * rrndmax) * (max-min) + min;
}
void esBind(const GLenum target, GLuint* buffer, const void* data, const GLsizeiptr datalen, const GLenum usage)
{
    glGenBuffers(1, buffer);
    glBindBuffer(target, *buffer);
    glBufferData(target, datalen, data, usage);
}
void esRebind(const GLenum target, GLuint* buffer, const void* data, const GLsizeiptr datalen, const GLenum usage)
{
    glBindBuffer(target, *buffer);
    glBufferData(target, datalen, data, usage);
}
#ifdef GL_DEBUG
void GLAPIENTRY MessageCallback( GLenum source,
                 GLenum type,
                 GLuint id,
                 GLenum severity,
                 GLsizei length,
                 const GLchar* message,
                 const void* userParam )
{
    printf("GL CALLBACK: %s type = 0x%x, severity = 0x%x, message = %s\n",
        ( type == GL_DEBUG_TYPE_ERROR ? "** GL ERROR **" : "" ),
            type, severity, message );
}
void esDebug(const GLuint state)
{
    if(state == 1)
    {
        glEnable(GL_DEBUG_OUTPUT);
        glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
        glDebugMessageCallback(MessageCallback, 0);
        glDebugMessageControl(GL_DEBUG_SOURCE_API, GL_DONT_CARE, GL_DEBUG_SEVERITY_NOTIFICATION, 0, NULL, GL_FALSE);
    }
    else
    {
        glDisable(GL_DEBUG_OUTPUT);
        glDisable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
    }
}
#endif
#ifdef MAX_MODELS
    ESModel esModelArray[MAX_MODELS];
    uint esModelArray_index = 0;
    uint esBoundModel = 0;
    void esBindModel(const uint id)
    {
        glBindBuffer(GL_ARRAY_BUFFER, esModelArray[id].vid);
        glVertexAttribPointer(position_id, 3, GL_FLOAT, GL_FALSE, 0, 0);
        glEnableVertexAttribArray(position_id);
        glBindBuffer(GL_ARRAY_BUFFER, esModelArray[id].nid);
        glVertexAttribPointer(normal_id, 3, GL_FLOAT, GL_FALSE, 0, 0);
        glEnableVertexAttribArray(normal_id);
        glBindBuffer(GL_ARRAY_BUFFER, esModelArray[id].cid);
        glVertexAttribPointer(color_id, 3, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
        glEnableVertexAttribArray(color_id);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, esModelArray[id].iid);
        esBoundModel = id;
    }
    void esBindModelF(const uint id)
    {
        glBindBuffer(GL_ARRAY_BUFFER, esModelArray[id].vid);
        glVertexAttribPointer(position_id, 3, GL_FLOAT, GL_FALSE, 0, 0);
        glEnableVertexAttribArray(position_id);
        glBindBuffer(GL_ARRAY_BUFFER, esModelArray[id].cid);
        glVertexAttribPointer(color_id, 3, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
        glEnableVertexAttribArray(color_id);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, esModelArray[id].iid);
        esBoundModel = id;
    }
    void esRenderModel()
    {
        glDrawElements(GL_TRIANGLES, esModelArray[esBoundModel].ni, esModelArray[esBoundModel].itp, 0);
    }
    void esBindRender(const uint id)
    {
        glBindBuffer(GL_ARRAY_BUFFER, esModelArray[id].vid);
        glVertexAttribPointer(position_id, 3, GL_FLOAT, GL_FALSE, 0, 0);
        glEnableVertexAttribArray(position_id);
        glBindBuffer(GL_ARRAY_BUFFER, esModelArray[id].nid);
        glVertexAttribPointer(normal_id, 3, GL_FLOAT, GL_FALSE, 0, 0);
        glEnableVertexAttribArray(normal_id);
        glBindBuffer(GL_ARRAY_BUFFER, esModelArray[id].cid);
        glVertexAttribPointer(color_id, 3, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
        glEnableVertexAttribArray(color_id);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, esModelArray[id].iid);
        glDrawElements(GL_TRIANGLES, esModelArray[id].ni, esModelArray[id].itp, 0);
    }
    void esBindRenderS(const uint id)
    {
        glBindBuffer(GL_ARRAY_BUFFER, esModelArray[id].vid);
        glVertexAttribPointer(position_id, 3, GL_FLOAT, GL_FALSE, 0, 0);
        glEnableVertexAttribArray(position_id);
        glBindBuffer(GL_ARRAY_BUFFER, esModelArray[id].nid);
        glVertexAttribPointer(normal_id, 3, GL_FLOAT, GL_FALSE, 0, 0);
        glEnableVertexAttribArray(normal_id);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, esModelArray[id].iid);
        glDrawElements(GL_TRIANGLES, esModelArray[id].ni, esModelArray[id].itp, 0);
    }
    void esBindRenderF(const uint id)
    {
        glBindBuffer(GL_ARRAY_BUFFER, esModelArray[id].vid);
        glVertexAttribPointer(position_id, 3, GL_FLOAT, GL_FALSE, 0, 0);
        glEnableVertexAttribArray(position_id);
        glBindBuffer(GL_ARRAY_BUFFER, esModelArray[id].cid);
        glVertexAttribPointer(color_id, 3, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
        glEnableVertexAttribArray(color_id);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, esModelArray[id].iid);
        glDrawElements(GL_TRIANGLES, esModelArray[id].ni, esModelArray[id].itp, 0);
    }
#define esLoadModel(x) \
 esBind(GL_ARRAY_BUFFER, &esModelArray[esModelArray_index].vid, x##_vertices, sizeof(x##_vertices[0]) * x##_numvert * 3, GL_STATIC_DRAW); \
 esBind(GL_ARRAY_BUFFER, &esModelArray[esModelArray_index].nid, x##_normals, sizeof(x##_normals[0]) * x##_numvert * 3, GL_STATIC_DRAW); \
 esBind(GL_ARRAY_BUFFER, &esModelArray[esModelArray_index].cid, x##_colors, sizeof(x##_colors[0]) * x##_numvert * 3, GL_STATIC_DRAW); \
 esBind(GL_ELEMENT_ARRAY_BUFFER, &esModelArray[esModelArray_index].iid, x##_indices, sizeof(x##_indices[0]) * x##_numind * 3, GL_STATIC_DRAW); \
 esModelArray[esModelArray_index].itp = x##_GL_TYPE; \
 esModelArray[esModelArray_index].ni = x##_numind * 3; \
 esModelArray_index++;
#endif
const GLchar* v0 =
    "#version 100\n"
    "uniform mat4 modelview;\n"
    "uniform mat4 projection;\n"
    "uniform float lightness;\n"
    "uniform vec3 color;\n"
    "uniform float opacity;\n"
    "attribute vec4 position;\n"
    "varying vec4 fragcolor;\n"
    "void main()\n"
    "{\n"
        "fragcolor = vec4(color*lightness, opacity);\n"
        "gl_Position = projection * modelview * position;\n"
    "}\n";
const GLchar* f0 =
    "#version 100\n"
    "precision highp float;\n"
    "varying vec4 fragcolor;\n"
    "void main()\n"
    "{\n"
        "gl_FragColor = fragcolor;\n"
    "}\n";
const GLchar* v01 =
    "#version 100\n"
    "uniform mat4 modelview;\n"
    "uniform mat4 projection;\n"
    "uniform float lightness;\n"
    "attribute vec3 color;\n"
    "uniform float opacity;\n"
    "attribute vec4 position;\n"
    "varying vec3 vertCol;\n"
    "varying float vertOpa;\n"
    "void main()\n"
    "{\n"
        "vertCol = color*lightness;\n"
        "vertOpa = opacity;\n"
        "gl_Position = projection * modelview * position;\n"
    "}\n";
const GLchar* f01 =
    "#version 100\n"
    "precision highp float;\n"
    "varying vec3 vertCol;\n"
    "varying float vertOpa;\n"
    "void main()\n"
    "{\n"
        "gl_FragColor = vec4(vertCol, vertOpa);\n"
    "}\n";
#ifdef VERTEX_SHADE
const GLchar* v1 =
    "#version 100\n"
    "uniform mat4 modelview;\n"
    "uniform mat4 projection;\n"
    "uniform vec3 color;\n"
    "uniform float ambient;\n"
    "uniform float saturate;\n"
    "uniform float opacity;\n"
    "uniform vec3 lightpos;\n"
    "attribute vec4 position;\n"
    "attribute vec3 normal;\n"
    "varying vec4 fragcolor;\n"
    "void main()\n"
    "{\n"
        "vec4 vertPos4 = modelview * position;\n"
        "vec3 vertNorm = normalize(vec3(modelview * vec4(normal, 0.0)));\n"
        "vec3 lightDir = normalize(lightpos - (vertPos4.xyz / vertPos4.w));\n"
        "fragcolor = vec4((color*ambient) + (color * min(max(dot(lightDir, vertNorm), 0.0), saturate)), opacity);\n"
        "gl_Position = projection * vertPos4;\n"
    "}\n";
const GLchar* v2 =
    "#version 100\n"
    "uniform mat4 modelview;\n"
    "uniform mat4 projection;\n"
    "uniform float ambient;\n"
    "uniform float saturate;\n"
    "uniform float opacity;\n"
    "uniform vec3 lightpos;\n"
    "attribute vec4 position;\n"
    "attribute vec3 normal;\n"
    "attribute vec3 color;\n"
    "varying vec4 fragcolor;\n"
    "void main()\n"
    "{\n"
        "vec4 vertPos4 = modelview * position;\n"
        "vec3 vertNorm = normalize(vec3(modelview * vec4(normal, 0.0)));\n"
        "vec3 lightDir = normalize(lightpos - (vertPos4.xyz / vertPos4.w));\n"
        "fragcolor = vec4((color*ambient) + (color * min(max(dot(lightDir, vertNorm), 0.0), saturate)), opacity);\n"
        "gl_Position = projection * vertPos4;\n"
    "}\n";
const GLchar* f1 =
    "#version 100\n"
    "precision highp float;\n"
    "varying vec4 fragcolor;\n"
    "void main()\n"
    "{\n"
        "gl_FragColor = fragcolor;\n"
    "}\n";
const GLchar* v3 =
    "#version 100\n"
    "uniform mat4 modelview;\n"
    "uniform mat4 projection;\n"
    "uniform float ambient;\n"
    "uniform float specular;\n"
    "uniform float specpower;\n"
    "uniform vec3 hsv;\n"
    "uniform float viewdist;\n"
    "uniform float opacity;\n"
    "uniform vec3 lightpos;\n"
    "attribute vec4 position;\n"
    "attribute vec3 normal;\n"
    "attribute vec3 color;\n"
    "varying vec4 fragcolor;\n"
    "vec3 rgb2hsv(vec3 c)\n"
    "{\n"
        "vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);\n"
        "vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));\n"
        "vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));\n"
        "float d = q.x - min(q.w, q.y);\n"
        "float e = 1.0e-10;\n"
        "return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);\n"
    "}\n"
    "vec3 hsv2rgb(vec3 c)\n"
    "{\n"
        "vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n"
        "vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);\n"
        "return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);\n"
    "}\n"
    "void main()\n"
    "{\n"
        "vec4 vertPos4 = modelview * position;\n"
        "vec3 vertPos = vertPos4.xyz / vertPos4.w;\n"
        "vec3 vertNorm = normalize(vec3(modelview * vec4(normal, 0.0)));\n"
        "vec3 vertCol = rgb2hsv(color);\n"
        "vertCol += hsv;\n"
        "vertCol = hsv2rgb(vertCol);\n"
        "gl_Position = projection * vertPos4;\n"
        "vec3 lightDir = normalize(lightpos - vertPos);\n"
        "vec3 viewDir = normalize(-vertPos);\n"
#ifndef BLINN_PHONG
        "vec3 reflectDir = reflect(-lightDir, vertNorm);\n"
#else
        "vec3 halfDir = normalize(viewDir + lightDir);\n"
#endif
        "float lumosity = max(dot(lightDir, vertNorm), 0.0);\n"
        "vec3 spectotal = vertCol;\n"
#ifndef BLINN_PHONG
        "float specAngle = max(dot(reflectDir, viewDir), 0.0);\n"
#else
        "float specAngle = max(dot(halfDir, vertNorm), 0.0);\n"
#endif
        "spectotal += pow(specAngle, specpower) * (vertCol*specular);\n"
        "fragcolor = vec4( ((vertCol*ambient) + (spectotal * lumosity)) * clamp(1.0 - (length(vertPos)*viewdist), 0.0, 1.0), opacity);\n"
    "}\n";
const GLchar* f2 =
    "#version 100\n"
    "precision highp float;\n"
    "varying vec4 fragcolor;\n"
    "void main()\n"
    "{\n"
        "gl_FragColor = fragcolor;\n"
    "}\n";
#else
const GLchar* v1 =
    "#version 100\n"
    "uniform mat4 modelview;\n"
    "uniform mat4 projection;\n"
    "uniform vec3 color;\n"
    "uniform float ambient;\n"
    "uniform float saturate;\n"
    "uniform float opacity;\n"
    "uniform vec3 lightpos;\n"
    "attribute vec4 position;\n"
    "attribute vec3 normal;\n"
    "varying vec3 vertPos;\n"
    "varying vec3 vertNorm;\n"
    "varying vec3 vertCol;\n"
    "varying float vertAmb;\n"
    "varying float vertSat;\n"
    "varying float vertOpa;\n"
    "varying vec3 vlightPos;\n"
    "void main()\n"
    "{\n"
        "vec4 vertPos4 = modelview * position;\n"
        "vertPos = vertPos4.xyz / vertPos4.w;\n"
        "vertNorm = vec3(modelview * vec4(normal, 0.0));\n"
        "vertCol = color;\n"
        "vertAmb = ambient;\n"
        "vertSat = saturate;\n"
        "vertOpa = opacity;\n"
        "vlightPos = lightpos;\n"
        "gl_Position = projection * vertPos4;\n"
    "}\n";
const GLchar* v2 =
    "#version 100\n"
    "uniform mat4 modelview;\n"
    "uniform mat4 projection;\n"
    "uniform float ambient;\n"
    "uniform float saturate;\n"
    "uniform float opacity;\n"
    "uniform vec3 lightpos;\n"
    "attribute vec4 position;\n"
    "attribute vec3 normal;\n"
    "attribute vec3 color;\n"
    "varying vec3 vertPos;\n"
    "varying vec3 vertNorm;\n"
    "varying vec3 vertCol;\n"
    "varying float vertAmb;\n"
    "varying float vertSat;\n"
    "varying float vertOpa;\n"
    "varying vec3 vlightPos;\n"
    "void main()\n"
    "{\n"
        "vec4 vertPos4 = modelview * position;\n"
        "vertPos = vertPos4.xyz / vertPos4.w;\n"
        "vertNorm = vec3(modelview * vec4(normal, 0.0));\n"
        "vertCol = color;\n"
        "vertAmb = ambient;\n"
        "vertSat = saturate;\n"
        "vertOpa = opacity;\n"
        "vlightPos = lightpos;\n"
        "gl_Position = projection * vertPos4;\n"
    "}\n";
const GLchar* f1 =
    "#version 100\n"
    "precision highp float;\n"
    "varying vec3 vertPos;\n"
    "varying vec3 vertNorm;\n"
    "varying vec3 vertCol;\n"
    "varying float vertAmb;\n"
    "varying float vertSat;\n"
    "varying float vertOpa;\n"
    "varying vec3 vlightPos;\n"
    "void main()\n"
    "{\n"
        "vec3 lightDir = normalize(vlightPos - vertPos);\n"
        "float lambertian = min(max(dot(lightDir, normalize(vertNorm)), 0.0), vertSat);\n"
        "gl_FragColor = vec4((vertCol*vertAmb) + (vertCol*lambertian), vertOpa);\n"
    "}\n";
const GLchar* v3 =
    "#version 100\n"
    "uniform mat4 modelview;\n"
    "uniform mat4 projection;\n"
    "uniform float ambient;\n"
    "uniform float specular;\n"
    "uniform float specpower;\n"
    "uniform vec3 hsv;\n"
    "uniform float viewdist;\n"
    "uniform float opacity;\n"
    "uniform vec3 lightpos;\n"
    "attribute vec4 position;\n"
    "attribute vec3 normal;\n"
    "attribute vec3 color;\n"
    "varying vec3 vertPos;\n"
    "varying vec3 vertNorm;\n"
    "varying vec3 vertCol;\n"
    "varying float vertAmb;\n"
    "varying float vertSpec;\n"
    "varying float vertSpecPow;\n"
    "varying float vertViewDist;\n"
    "varying float vertOpa;\n"
    "varying vec3 vlightPos;\n"
    "vec3 rgb2hsv(vec3 c)\n"
    "{\n"
        "vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);\n"
        "vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));\n"
        "vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));\n"
        "float d = q.x - min(q.w, q.y);\n"
        "float e = 1.0e-10;\n"
        "return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);\n"
    "}\n"
    "vec3 hsv2rgb(vec3 c)\n"
    "{\n"
        "vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n"
        "vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);\n"
        "return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);\n"
    "}\n"
    "void main()\n"
    "{\n"
        "vec4 vertPos4 = modelview * position;\n"
        "vertPos = vertPos4.xyz / vertPos4.w;\n"
        "vertNorm = normalize(vec3(modelview * vec4(normal, 0.0)));\n"
        "vertCol = rgb2hsv(color);\n"
        "vertCol += hsv;\n"
        "vertCol = hsv2rgb(vertCol);\n"
        "vertAmb = ambient;\n"
        "vertSpec = specular;\n"
        "vertSpecPow = specpower;\n"
        "vertViewDist = viewdist;\n"
        "vertOpa = opacity;\n"
        "vlightPos = lightpos;\n"
        "gl_Position = projection * vertPos4;\n"
    "}\n";
const GLchar* f2 =
    "#version 100\n"
    "precision highp float;\n"
    "varying vec3 vertPos;\n"
    "varying vec3 vertNorm;\n"
    "varying vec3 vertCol;\n"
    "varying float vertAmb;\n"
    "varying float vertSpec;\n"
    "varying float vertSpecPow;\n"
    "varying float vertViewDist;\n"
    "varying float vertOpa;\n"
    "varying vec3 vlightPos;\n"
    "void main()\n"
    "{\n"
        "vec3 lightDir = normalize(vlightPos - vertPos);\n"
        "vec3 viewDir = normalize(-vertPos);\n"
#ifndef BLINN_PHONG
        "vec3 reflectDir = reflect(-lightDir, vertNorm);\n"
#else
        "vec3 halfDir = normalize(viewDir + lightDir);\n"
#endif
        "float lumosity = max(dot(lightDir, vertNorm), 0.0);\n"
        "vec3 specular = vertCol;\n"
#ifndef BLINN_PHONG
        "float specAngle = max(dot(reflectDir, viewDir), 0.0);\n"
#else
        "float specAngle = max(dot(halfDir, vertNorm), 0.0);\n"
#endif
        "specular += pow(specAngle, vertSpecPow) * (vertCol*vertSpec);\n"
        "gl_FragColor = vec4( ((vertCol*vertAmb) + (specular * lumosity)) * clamp(1.0 - (length(vertPos)*vertViewDist), 0.0, 1.0), vertOpa);\n"
    "}\n";
#endif
GLuint shdFullbrightSolid;
GLint shdFullbrightSolid_position;
GLint shdFullbrightSolid_projection;
GLint shdFullbrightSolid_modelview;
GLint shdFullbrightSolid_color;
GLint shdFullbrightSolid_opacity;
GLint shdFullbrightSolid_lightness;
GLuint shdFullbright;
GLint shdFullbright_position;
GLint shdFullbright_projection;
GLint shdFullbright_modelview;
GLint shdFullbright_color;
GLint shdFullbright_opacity;
GLint shdFullbright_lightness;
GLuint shdLambertSolid;
GLint shdLambertSolid_position;
GLint shdLambertSolid_projection;
GLint shdLambertSolid_modelview;
GLint shdLambertSolid_lightpos;
GLint shdLambertSolid_color;
GLint shdLambertSolid_normal;
GLint shdLambertSolid_ambient;
GLint shdLambertSolid_saturate;
GLint shdLambertSolid_opacity;
GLuint shdLambert;
GLint shdLambert_position;
GLint shdLambert_projection;
GLint shdLambert_modelview;
GLint shdLambert_lightpos;
GLint shdLambert_color;
GLint shdLambert_normal;
GLint shdLambert_ambient;
GLint shdLambert_saturate;
GLint shdLambert_opacity;
GLuint shdPhong;
GLint shdPhong_position;
GLint shdPhong_projection;
GLint shdPhong_modelview;
GLint shdPhong_lightpos;
GLint shdPhong_color;
GLint shdPhong_normal;
GLint shdPhong_ambient;
GLint shdPhong_specular;
GLint shdPhong_specpower;
GLint shdPhong_hsv;
GLint shdPhong_viewdist;
GLint shdPhong_opacity;
GLuint debugShader(GLuint shader_program)
{
    GLint linked;
    glGetProgramiv(shader_program, GL_LINK_STATUS, &linked);
    if(linked == GL_FALSE)
    {
        GLint infoLen = 0;
        glGetProgramiv(shader_program, GL_INFO_LOG_LENGTH, &infoLen);
        if(infoLen > 1)
        {
            char* infoLog = malloc(sizeof(char) * infoLen);
            if(infoLog != NULL)
            {
                glGetProgramInfoLog(shader_program, infoLen, NULL, infoLog);
                printf("!!! error linking shader !!!\n%s\n", infoLog);
                free(infoLog);
            }
        }
        else
        {
            printf("!!! failed to link shader with no returned debug output !!!\n");
        }
        glDeleteProgram(shader_program);
        return linked;
    }
    return linked;
}
void makeFullbrightSolid()
{
    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &v0, NULL);
    glCompileShader(vertexShader);
    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &f0, NULL);
    glCompileShader(fragmentShader);
    shdFullbrightSolid = glCreateProgram();
        glAttachShader(shdFullbrightSolid, vertexShader);
        glAttachShader(shdFullbrightSolid, fragmentShader);
    glLinkProgram(shdFullbrightSolid);
    if(debugShader(shdFullbrightSolid) == GL_FALSE){return;}
    shdFullbrightSolid_position = glGetAttribLocation(shdFullbrightSolid, "position");
    shdFullbrightSolid_projection = glGetUniformLocation(shdFullbrightSolid, "projection");
    shdFullbrightSolid_modelview = glGetUniformLocation(shdFullbrightSolid, "modelview");
    shdFullbrightSolid_color = glGetUniformLocation(shdFullbrightSolid, "color");
    shdFullbrightSolid_opacity = glGetUniformLocation(shdFullbrightSolid, "opacity");
    shdFullbrightSolid_lightness = glGetUniformLocation(shdFullbrightSolid, "lightness");
}
void makeFullbright()
{
    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &v01, NULL);
    glCompileShader(vertexShader);
    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &f01, NULL);
    glCompileShader(fragmentShader);
    shdFullbright = glCreateProgram();
        glAttachShader(shdFullbright, vertexShader);
        glAttachShader(shdFullbright, fragmentShader);
    glLinkProgram(shdFullbright);
    if(debugShader(shdFullbright) == GL_FALSE){return;}
    shdFullbright_position = glGetAttribLocation(shdFullbright, "position");
    shdFullbright_color = glGetAttribLocation(shdFullbright, "color");
    shdFullbright_projection = glGetUniformLocation(shdFullbright, "projection");
    shdFullbright_modelview = glGetUniformLocation(shdFullbright, "modelview");
    shdFullbright_opacity = glGetUniformLocation(shdFullbright, "opacity");
    shdFullbright_lightness = glGetUniformLocation(shdFullbright, "lightness");
}
void makeLambertSolid()
{
    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &v1, NULL);
    glCompileShader(vertexShader);
    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &f1, NULL);
    glCompileShader(fragmentShader);
    shdLambertSolid = glCreateProgram();
        glAttachShader(shdLambertSolid, vertexShader);
        glAttachShader(shdLambertSolid, fragmentShader);
    glLinkProgram(shdLambertSolid);
    if(debugShader(shdLambertSolid) == GL_FALSE){return;}
    shdLambertSolid_position = glGetAttribLocation(shdLambertSolid, "position");
    shdLambertSolid_normal = glGetAttribLocation(shdLambertSolid, "normal");
    shdLambertSolid_projection = glGetUniformLocation(shdLambertSolid, "projection");
    shdLambertSolid_modelview = glGetUniformLocation(shdLambertSolid, "modelview");
    shdLambertSolid_lightpos = glGetUniformLocation(shdLambertSolid, "lightpos");
    shdLambertSolid_color = glGetUniformLocation(shdLambertSolid, "color");
    shdLambertSolid_ambient = glGetUniformLocation(shdLambertSolid, "ambient");
    shdLambertSolid_saturate = glGetUniformLocation(shdLambertSolid, "saturate");
    shdLambertSolid_opacity = glGetUniformLocation(shdLambertSolid, "opacity");
}
void makeLambert()
{
    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &v2, NULL);
    glCompileShader(vertexShader);
    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &f1, NULL);
    glCompileShader(fragmentShader);
    shdLambert = glCreateProgram();
        glAttachShader(shdLambert, vertexShader);
        glAttachShader(shdLambert, fragmentShader);
    glLinkProgram(shdLambert);
    if(debugShader(shdLambert) == GL_FALSE){return;}
    shdLambert_position = glGetAttribLocation(shdLambert, "position");
    shdLambert_normal = glGetAttribLocation(shdLambert, "normal");
    shdLambert_color = glGetAttribLocation(shdLambert, "color");
    shdLambert_projection = glGetUniformLocation(shdLambert, "projection");
    shdLambert_modelview = glGetUniformLocation(shdLambert, "modelview");
    shdLambert_lightpos = glGetUniformLocation(shdLambert, "lightpos");
    shdLambert_ambient = glGetUniformLocation(shdLambert, "ambient");
    shdLambert_saturate = glGetUniformLocation(shdLambert, "saturate");
    shdLambert_opacity = glGetUniformLocation(shdLambert, "opacity");
}
void makePhong()
{
    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &v3, NULL);
    glCompileShader(vertexShader);
    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &f2, NULL);
    glCompileShader(fragmentShader);
    shdPhong = glCreateProgram();
        glAttachShader(shdPhong, vertexShader);
        glAttachShader(shdPhong, fragmentShader);
    glLinkProgram(shdPhong);
    if(debugShader(shdPhong) == GL_FALSE){return;}
    shdPhong_position = glGetAttribLocation(shdPhong, "position");
    shdPhong_normal = glGetAttribLocation(shdPhong, "normal");
    shdPhong_color = glGetAttribLocation(shdPhong, "color");
    shdPhong_projection = glGetUniformLocation(shdPhong, "projection");
    shdPhong_modelview = glGetUniformLocation(shdPhong, "modelview");
    shdPhong_lightpos = glGetUniformLocation(shdPhong, "lightpos");
    shdPhong_ambient = glGetUniformLocation(shdPhong, "ambient");
    shdPhong_specular = glGetUniformLocation(shdPhong, "specular");
    shdPhong_specpower = glGetUniformLocation(shdPhong, "specpower");
    shdPhong_hsv = glGetUniformLocation(shdPhong, "hsv");
    shdPhong_viewdist = glGetUniformLocation(shdPhong, "viewdist");
    shdPhong_opacity = glGetUniformLocation(shdPhong, "opacity");
}
void makeAllShaders()
{
    makeFullbrightSolid();
    makeFullbright();
    makeLambertSolid();
    makeLambert();
    makePhong();
}
void shadeFullbrightSolid(GLint* position, GLint* iprojection, GLint* imodelview, GLint* color, GLint* lightness, GLint* opacity)
{
    *position = shdFullbrightSolid_position;
    *iprojection = shdFullbrightSolid_projection;
    *imodelview = shdFullbrightSolid_modelview;
    *color = shdFullbrightSolid_color;
    *opacity = shdFullbrightSolid_opacity;
    *lightness = shdFullbrightSolid_lightness;
    glUseProgram(shdFullbrightSolid);
}
void shadeFullbright(GLint* position, GLint* iprojection, GLint* imodelview, GLint* color, GLint* lightness, GLint* opacity)
{
    *position = shdFullbright_position;
    *iprojection = shdFullbright_projection;
    *imodelview = shdFullbright_modelview;
    *color = shdFullbright_color;
    *opacity = shdFullbright_opacity;
    *lightness = shdFullbright_lightness;
    glUseProgram(shdFullbright);
}
void shadeLambertSolid(GLint* position, GLint* iprojection, GLint* imodelview, GLint* lightpos, GLint* normal, GLint* color, GLint* ambient, GLint* saturate, GLint* opacity)
{
    *position = shdLambertSolid_position;
    *iprojection = shdLambertSolid_projection;
    *imodelview = shdLambertSolid_modelview;
    *lightpos = shdLambertSolid_lightpos;
    *color = shdLambertSolid_color;
    *normal = shdLambertSolid_normal;
    *ambient = shdLambertSolid_ambient;
    *saturate = shdLambertSolid_saturate;
    *opacity = shdLambertSolid_opacity;
    glUseProgram(shdLambertSolid);
}
void shadeLambert(GLint* position, GLint* iprojection, GLint* imodelview, GLint* lightpos, GLint* normal, GLint* color, GLint* ambient, GLint* saturate, GLint* opacity)
{
    *position = shdLambert_position;
    *iprojection = shdLambert_projection;
    *imodelview = shdLambert_modelview;
    *lightpos = shdLambert_lightpos;
    *color = shdLambert_color;
    *normal = shdLambert_normal;
    *ambient = shdLambert_ambient;
    *saturate = shdLambert_saturate;
    *opacity = shdLambert_opacity;
    glUseProgram(shdLambert);
}
void shadePhong(GLint* position, GLint* iprojection, GLint* imodelview, GLint* lightpos, GLint* normal, GLint* color, GLint* ambient, GLint* specular, GLint* specpower, GLint* hsv, GLint* viewdist, GLint* opacity)
{
    *position = shdPhong_position;
    *iprojection = shdPhong_projection;
    *imodelview = shdPhong_modelview;
    *lightpos = shdPhong_lightpos;
    *color = shdPhong_color;
    *normal = shdPhong_normal;
    *ambient = shdPhong_ambient;
    *specular = shdPhong_specular;
    *specpower = shdPhong_specpower;
    *hsv = shdPhong_hsv;
    *viewdist = shdPhong_viewdist;
    *opacity = shdPhong_opacity;
    glUseProgram(shdPhong);
}
#include <math.h>
#include <string.h>
int srandfq = 74235;
static inline void srandf(const int seed){srandfq = seed;}
static inline float randf()
{
    srandfq *= 16807;
    return (float)(srandfq & 0x7FFFFFFF) * 4.6566129e-010f;
}
static inline float randfc()
{
    srandfq *= 16807;
    return ((float)(srandfq)) * 4.6566129e-010f;
}
static inline float fRandFloat(const float min, const float max)
{
    return min + randf() * (max-min);
}
static inline int fRand(const float min, const float max)
{
    return (int)((min + randf() * (max-min))+0.5f);
}
float randfn()
{
    float u = randfc();
    float v = randfc();
    float r = u * u + v * v;
    while(r == 0.f || r > 1.f)
    {
        u = randfc();
        v = randfc();
        r = u * u + v * v;
    }
    return u * sqrtf(-2.f * logf(r) / r);
}
void vRuv(vec* v)
{
    v->x = randfc();
    v->y = randfc();
    v->z = randfc();
}
void vRuvN(vec* v)
{
    v->x = randfn();
    v->y = randfn();
    v->z = randfn();
}
void vRuvBT(vec* v)
{
    const float y = acosf(randfc()) - d2PI;
    const float p = x2PI * randf();
    v->x = cosf(y) * cosf(p);
    v->y = cosf(y) * sinf(p);
    v->z = sinf(y);
}
void vRuvTA(vec* v)
{
    while(1)
    {
        v->x = randfc();
        v->y = randfc();
        v->z = randfc();
        const float len = vMag(*v);
        if(len <= 1.0f){return;}
    }
}
void vRuvTD(vec* v)
{
    v->x = sinf((randf() * x2PI) - PI);
    v->y = cosf((randf() * x2PI) - PI);
    v->z = randfc();
}
void vCross(vec* r, const vec v1, const vec v2)
{
    r->x = (v1.y * v2.z) - (v2.y * v1.z);
    r->y = -((v1.x * v2.z) - (v2.x * v1.z));
    r->z = (v1.x * v2.y) - (v2.x * v1.y);
}
float vDot(const vec v1, const vec v2)
{
    return (v1.x * v2.x) + (v1.y * v2.y) + (v1.z * v2.z);
}
float vSum(const vec v)
{
    return v.x + v.y + v.z;
}
float vSumAbs(const vec v)
{
    return fabs(v.x) + fabs(v.y) + fabs(v.z);
}
void vInv(vec* v)
{
    v->x = -v->x;
    v->y = -v->y;
    v->z = -v->z;
}
void vNorm(vec* v)
{
    const float len = 1.f/sqrtf(v->x*v->x + v->y*v->y + v->z*v->z);
    v->x *= len;
    v->y *= len;
    v->z *= len;
}
float vDist(const vec v1, const vec v2)
{
    const float xm = (v1.x - v2.x);
    const float ym = (v1.y - v2.y);
    const float zm = (v1.z - v2.z);
    return sqrtf(xm*xm + ym*ym + zm*zm);
}
float vDistSq(const vec a, const vec b)
{
    const float xm = (a.x - b.x);
    const float ym = (a.y - b.y);
    const float zm = (a.z - b.z);
    return xm*xm + ym*ym + zm*zm;
}
float vDistMh(const vec a, const vec b)
{
    return (a.x - b.x) + (a.y - b.y) + (a.z - b.z);
}
float vDistLa(const vec v1, const vec v2)
{
    const float xm = fabsf(v1.x - v2.x);
    const float ym = fabsf(v1.y - v2.y);
    const float zm = fabsf(v1.z - v2.z);
    float dist = xm;
    if(ym > dist)
        dist = ym;
    if(zm > dist)
        dist = zm;
    return dist;
}
void vReflect(vec* r, const vec v, const vec n)
{
    const float angle = vDot(v, n);
    r->x = v.x - (2.f * n.x) * angle;
    r->y = v.y - (2.f * n.y) * angle;
    r->z = v.z - (2.f * n.z) * angle;
}
int vEqualTol(const vec a, const vec b, const float tol)
{
    return a.x >= b.x - tol && a.x <= b.x + tol &&
            a.y >= b.y - tol && a.y <= b.y + tol &&
            a.z >= b.z - tol && a.z <= b.z + tol;
}
void vMin(vec* r, const vec v1, const vec v2)
{
    if(v1.x < v2.x && v1.y < v2.y && v1.z < v2.z)
    {
        r->x = v1.x;
        r->y = v1.y;
        r->z = v1.z;
    }
    r->x = v2.x;
    r->y = v2.y;
    r->z = v2.z;
}
void vMax(vec* r, const vec v1, const vec v2)
{
    if(v1.x > v2.x && v1.y > v2.y && v1.z > v2.z)
    {
        r->x = v1.x;
        r->y = v1.y;
        r->z = v1.z;
    }
    r->x = v2.x;
    r->y = v2.y;
    r->z = v2.z;
}
int vec_ftoi(float f)
{
    if(f < 0.f)
        f -= 0.5f;
    else
        f += 0.5f;
    return (int)f;
}
int vEqualInt(const vec a, const vec b)
{
    return vec_ftoi(a.x) == vec_ftoi(b.x) && vec_ftoi(a.y) == vec_ftoi(b.y) && vec_ftoi(a.z) == vec_ftoi(b.z);
}
float vMod(const vec v)
{
    return sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
}
float vMag(const vec v)
{
    return v.x*v.x + v.y*v.y + v.z*v.z;
}
void vCopy(vec* r, const vec v)
{
    memcpy(r, &v, sizeof(vec));
}
void vDir(vec* r, const vec v1, const vec v2)
{
    vSub(r, v2, v1);
    vNorm(r);
}
void vRotX(vec* v, const float radians)
{
    v->y = v->y * cosf(radians) + v->z * sinf(radians);
    v->z = v->y * sinf(radians) - v->z * cosf(radians);
}
void vRotY(vec* v, const float radians)
{
    v->x = v->z * sinf(radians) - v->x * cosf(radians);
    v->z = v->z * cosf(radians) + v->x * sinf(radians);
}
void vRotZ(vec* v, const float radians)
{
    v->x = v->x * cosf(radians) + v->y * sinf(radians);
    v->y = v->x * sinf(radians) - v->y * cosf(radians);
}
void vAdd(vec* r, const vec v1, const vec v2)
{
    r->x = v1.x + v2.x;
    r->y = v1.y + v2.y;
    r->z = v1.z + v2.z;
}
void vSub(vec* r, const vec v1, const vec v2)
{
    r->x = v1.x - v2.x;
    r->y = v1.y - v2.y;
    r->z = v1.z - v2.z;
}
void vDiv(vec* r, const vec numerator, const vec denominator)
{
    r->x = numerator.x / denominator.x;
    r->y = numerator.y / denominator.y;
    r->z = numerator.z / denominator.z;
}
void vMul(vec* r, const vec v1, const vec v2)
{
    r->x = v1.x * v2.x;
    r->y = v1.y * v2.y;
    r->z = v1.z * v2.z;
}
void vAddS(vec* r, const vec v1, const float v2)
{
    r->x = v1.x + v2;
    r->y = v1.y + v2;
    r->z = v1.z + v2;
}
void vSubS(vec* r, const vec v1, const float v2)
{
    r->x = v1.x - v2;
    r->y = v1.y - v2;
    r->z = v1.z - v2;
}
void vDivS(vec* r, const vec v1, const float v2)
{
    r->x = v1.x / v2;
    r->y = v1.y / v2;
    r->z = v1.z / v2;
}
void vMulS(vec* r, const vec v1, const float v2)
{
    r->x = v1.x * v2;
    r->y = v1.y * v2;
    r->z = v1.z * v2;
}
void mIdent(mat *m)
{
    memset(m, 0x0, sizeof(mat));
    m->m[0][0] = 1.0f;
    m->m[1][1] = 1.0f;
    m->m[2][2] = 1.0f;
    m->m[3][3] = 1.0f;
}
void mCopy(mat *r, const mat *v)
{
    memcpy(r, v, sizeof(mat));
}
void mMul(mat *r, const mat *a, const mat *b)
{
    mat tmp;
    for(int i = 0; i < 4; i++)
    {
        tmp.m[i][0] = (a->m[i][0] * b->m[0][0]) +
                        (a->m[i][1] * b->m[1][0]) +
                        (a->m[i][2] * b->m[2][0]) +
                        (a->m[i][3] * b->m[3][0]) ;
        tmp.m[i][1] = (a->m[i][0] * b->m[0][1]) +
                        (a->m[i][1] * b->m[1][1]) +
                        (a->m[i][2] * b->m[2][1]) +
                        (a->m[i][3] * b->m[3][1]) ;
        tmp.m[i][2] = (a->m[i][0] * b->m[0][2]) +
                        (a->m[i][1] * b->m[1][2]) +
                        (a->m[i][2] * b->m[2][2]) +
                        (a->m[i][3] * b->m[3][2]) ;
        tmp.m[i][3] = (a->m[i][0] * b->m[0][3]) +
                        (a->m[i][1] * b->m[1][3]) +
                        (a->m[i][2] * b->m[2][3]) +
                        (a->m[i][3] * b->m[3][3]) ;
    }
    memcpy(r, &tmp, sizeof(mat));
}
void mMulP(vec *r, const mat *a, const float x, const float y, const float z)
{
    r->x = (a->m[0][0] * x) +
            (a->m[0][1] * x) +
            (a->m[0][2] * x) +
            (a->m[0][3] * x) ;
    r->y = (a->m[1][0] * y) +
            (a->m[1][1] * y) +
            (a->m[1][2] * y) +
            (a->m[1][3] * y) ;
    r->z = (a->m[2][0] * z) +
            (a->m[2][1] * z) +
            (a->m[2][2] * z) +
            (a->m[2][3] * z) ;
}
void mMulV(vec *r, const mat *a, const vec v)
{
    r->x = (a->m[0][0] * v.x) +
            (a->m[0][1] * v.x) +
            (a->m[0][2] * v.x) +
            (a->m[0][3] * v.x) ;
    r->y = (a->m[1][0] * v.y) +
            (a->m[1][1] * v.y) +
            (a->m[1][2] * v.y) +
            (a->m[1][3] * v.y) ;
    r->z = (a->m[2][0] * v.z) +
            (a->m[2][1] * v.z) +
            (a->m[2][2] * v.z) +
            (a->m[2][3] * v.z) ;
    r->w = (a->m[3][0] * v.w) +
            (a->m[3][1] * v.w) +
            (a->m[3][2] * v.w) +
            (a->m[3][3] * v.w) ;
}
void mScale(mat *r, const float x, const float y, const float z)
{
    r->m[0][0] *= x;
    r->m[0][1] *= x;
    r->m[0][2] *= x;
    r->m[0][3] *= x;
    r->m[1][0] *= y;
    r->m[1][1] *= y;
    r->m[1][2] *= y;
    r->m[1][3] *= y;
    r->m[2][0] *= z;
    r->m[2][1] *= z;
    r->m[2][2] *= z;
    r->m[2][3] *= z;
}
void mScale1(mat *r, const float s){mScale(r, s, s, s);}
void mTranslate(mat *r, const float x, const float y, const float z)
{
    r->m[3][0] += (r->m[0][0] * x + r->m[1][0] * y + r->m[2][0] * z);
    r->m[3][1] += (r->m[0][1] * x + r->m[1][1] * y + r->m[2][1] * z);
    r->m[3][2] += (r->m[0][2] * x + r->m[1][2] * y + r->m[2][2] * z);
    r->m[3][3] += (r->m[0][3] * x + r->m[1][3] * y + r->m[2][3] * z);
}
void mRotate(mat *r, const float radians, float x, float y, float z)
{
    const float mag = 1.f/sqrtf(x * x + y * y + z * z);
    const float sinAngle = sinf(radians);
    const float cosAngle = cosf(radians);
    if(mag > 0.0f)
    {
        x *= mag;
        y *= mag;
        z *= mag;
        const float xx = x * x;
        const float yy = y * y;
        const float zz = z * z;
        const float xy = x * y;
        const float yz = y * z;
        const float zx = z * x;
        const float xs = x * sinAngle;
        const float ys = y * sinAngle;
        const float zs = z * sinAngle;
        const float oneMinusCos = 1.0f - cosAngle;
        mat rotMat;
        rotMat.m[0][0] = (oneMinusCos * xx) + cosAngle;
        rotMat.m[0][1] = (oneMinusCos * xy) - zs;
        rotMat.m[0][2] = (oneMinusCos * zx) + ys;
        rotMat.m[0][3] = 0.0F;
        rotMat.m[1][0] = (oneMinusCos * xy) + zs;
        rotMat.m[1][1] = (oneMinusCos * yy) + cosAngle;
        rotMat.m[1][2] = (oneMinusCos * yz) - xs;
        rotMat.m[1][3] = 0.0F;
        rotMat.m[2][0] = (oneMinusCos * zx) - ys;
        rotMat.m[2][1] = (oneMinusCos * yz) + xs;
        rotMat.m[2][2] = (oneMinusCos * zz) + cosAngle;
        rotMat.m[2][3] = 0.0F;
        rotMat.m[3][0] = 0.0F;
        rotMat.m[3][1] = 0.0F;
        rotMat.m[3][2] = 0.0F;
        rotMat.m[3][3] = 1.0F;
        mMul(r, &rotMat, r);
    }
}
void mRotX(mat *r, const float radians)
{
    const float s = sinf(radians);
    const float c = cosf(radians);
    const mat t = { c, 0.f, s, 0.f,
                    0.f, 1.f, 0.f, 0.f,
                    -s, 0.f, c, 0.f,
                    0.f, 0.f, 0.f, 1.f };
    mMul(r, &t, r);
}
void mRotY(mat *r, const float radians)
{
    const float s = sinf(radians);
    const float c = cosf(radians);
    const mat t = { 1.f, 0.f, 0.f, 0.f,
                    0.f, c, -s, 0.f,
                    0.f, s, c, 0.f,
                    0.f, 0.f, 0.f, 1.f };
    mMul(r, &t, r);
}
void mRotZ(mat *r, const float radians)
{
    const float s = sinf(radians);
    const float c = cosf(radians);
    const mat t = { c, -s, 0.f, 0.f,
                    s, c, 0.f, 0.f,
                    0.f, 0.f, 1.f, 0.f,
                    0.f, 0.f, 0.f, 1.f };
    mMul(r, &t, r);
}
void mAngleAxisRotate(mat *r, const mat view, const float xrot, const float yrot, const float zrot)
{
    vec tmp0, tmp1;
    vec vecview[3] = {
        {view.m[0][0], view.m[1][0], view.m[2][0]},
        {view.m[0][1], view.m[1][1], view.m[2][1]},
        {view.m[0][2], view.m[1][2], view.m[2][2]}
    };
    vMulS(&tmp0, vecview[0], cosf(xrot));
    vCross(&tmp1, vecview[1], vecview[0]);
    vMulS(&tmp1, tmp1, sinf(xrot));
    vMulS(&vecview[0], vecview[1], vDot(vecview[1], vecview[0]) * (1.f - cosf(xrot)));
    vAdd(&vecview[0], vecview[0], tmp0);
    vAdd(&vecview[0], vecview[0], tmp1);
    vMulS(&tmp0, vecview[1], cosf(yrot));
    vCross(&tmp1, vecview[0], vecview[1]);
    vMulS(&tmp1, tmp1, sinf(yrot));
    vMulS(&vecview[1], vecview[0], vDot(vecview[0], vecview[1]) * (1.f - cosf(yrot)));
    vAdd(&vecview[1], vecview[1], tmp0);
    vAdd(&vecview[1], vecview[1], tmp1);
    vCross(&vecview[2], vecview[0], vecview[1]);
    vCross(&vecview[1], vecview[2], vecview[0]);
    vMulS(&tmp0, vecview[0], cosf(zrot));
    vCross(&tmp1, vecview[2], vecview[0]);
    vMulS(&tmp1, tmp1, sinf(zrot));
    vMulS(&vecview[0], vecview[2], vDot(vecview[2], vecview[0]) * (1.f - cosf(zrot)));
    vAdd(&vecview[0], vecview[0], tmp0);
    vAdd(&vecview[0], vecview[0], tmp1);
    vCross(&vecview[1], vecview[2], vecview[0]);
    vNorm(&vecview[0]);
    vNorm(&vecview[1]);
    vNorm(&vecview[2]);
    *r = (mat){
        vecview[0].x, vecview[1].x, vecview[2].x, 0.f,
        vecview[0].y, vecview[1].y, vecview[2].y, 0.f,
        vecview[0].z, vecview[1].z, vecview[2].z, 0.f,
        0.f, 0.f, 0.f, 1.f
    };
}
void mFrustum(mat *r, const float left, const float right, const float bottom, const float top, const float nearZ, const float farZ)
{
    const float dX = right - left;
    const float dY = top - bottom;
    const float dZ = farZ - nearZ;
    const float rdX = 1.f/dX;
    const float rdY = 1.f/dY;
    const float rdZ = 1.f/dZ;
    mat frust;
    if(nearZ <= 0.0f || farZ <= 0.0f || dX <= 0.0f || dY <= 0.0f || dZ <= 0.0f)
        return;
    frust.m[0][0] = 2.0f * nearZ * rdX;
    frust.m[0][1] = frust.m[0][2] = frust.m[0][3] = 0.0f;
    frust.m[1][1] = 2.0f * nearZ * rdY;
    frust.m[1][0] = frust.m[1][2] = frust.m[1][3] = 0.0f;
    frust.m[2][0] = (right + left) * rdX;
    frust.m[2][1] = (top + bottom) * rdY;
    frust.m[2][2] = -(nearZ + farZ) * rdZ;
    frust.m[2][3] = -1.0f;
    frust.m[3][2] = -2.0f * nearZ * farZ * rdZ;
    frust.m[3][0] = frust.m[3][1] = frust.m[3][3] = 0.0f;
    mMul(r, &frust, r);
}
void mPerspective(mat *r, const float fovy, const float aspect, const float nearZ, const float farZ)
{
    float frustumW, frustumH;
    frustumH = tanf(fovy * 0.00872664625f) * nearZ;
    frustumW = frustumH * aspect;
    mFrustum(r, -frustumW, frustumW, -frustumH, frustumH, nearZ, farZ);
}
void mOrtho(mat *r, const float left, const float right, const float bottom, const float top, const float nearZ, const float farZ)
{
    const float dX = right - left;
    const float dY = top - bottom;
    const float dZ = farZ - nearZ;
    const float rdX = 1.f/dX;
    const float rdY = 1.f/dY;
    const float rdZ = 1.f/dZ;
    mat ortho;
    if(dX == 0.0f || dY == 0.0f || dZ == 0.0f)
        return;
    mIdent(&ortho);
    ortho.m[0][0] = 2.0f * rdX;
    ortho.m[3][0] = -(right + left) * rdX;
    ortho.m[1][1] = 2.0f * rdY;
    ortho.m[3][1] = -(top + bottom) * rdY;
    ortho.m[2][2] = -2.0f * rdZ;
    ortho.m[3][2] = -(nearZ + farZ) * rdZ;
    mMul(r, &ortho, r);
}
void mLookAt(mat *r, const vec origin, const vec unit_dir)
{
    static const vec up = (vec){0.f, 0.f, 1.f};
    vec dirn;
    dirn.x = unit_dir.x;
    dirn.y = unit_dir.y;
    dirn.z = unit_dir.z;
    vec c;
    vCross(&c, up, dirn);
    vNorm(&c);
    vec rup;
    vCross(&rup, dirn, c);
    r->m[0][0] = c.x;
    r->m[0][1] = c.y;
    r->m[0][2] = c.z;
    r->m[1][0] = rup.x;
    r->m[1][1] = rup.y;
    r->m[1][2] = rup.z;
    r->m[2][0] = dirn.x;
    r->m[2][1] = dirn.y;
    r->m[2][2] = dirn.z;
    r->m[3][0] = origin.x;
    r->m[3][1] = origin.y;
    r->m[3][2] = origin.z;
}
void mInvert(float *dst, const float *mat)
{
    float tmp[12];
    float src[16];
    float det;
    for(int i = 0; i < 4; i++)
    {
        src[i] = mat[i*4];
        src[i + 4] = mat[i*4 + 1];
        src[i + 8] = mat[i*4 + 2];
        src[i + 12] = mat[i*4 + 3];
    }
    tmp[0] = src[10] * src[15];
    tmp[1] = src[11] * src[14];
    tmp[2] = src[9] * src[15];
    tmp[3] = src[11] * src[13];
    tmp[4] = src[9] * src[14];
    tmp[5] = src[10] * src[13];
    tmp[6] = src[8] * src[15];
    tmp[7] = src[11] * src[12];
    tmp[8] = src[8] * src[14];
    tmp[9] = src[10] * src[12];
    tmp[10] = src[8] * src[13];
    tmp[11] = src[9] * src[12];
    dst[0] = tmp[0]*src[5] + tmp[3]*src[6] + tmp[4]*src[7];
    dst[0] -= tmp[1]*src[5] + tmp[2]*src[6] + tmp[5]*src[7];
    dst[1] = tmp[1]*src[4] + tmp[6]*src[6] + tmp[9]*src[7];
    dst[1] -= tmp[0]*src[4] + tmp[7]*src[6] + tmp[8]*src[7];
    dst[2] = tmp[2]*src[4] + tmp[7]*src[5] + tmp[10]*src[7];
    dst[2] -= tmp[3]*src[4] + tmp[6]*src[5] + tmp[11]*src[7];
    dst[3] = tmp[5]*src[4] + tmp[8]*src[5] + tmp[11]*src[6];
    dst[3] -= tmp[4]*src[4] + tmp[9]*src[5] + tmp[10]*src[6];
    dst[4] = tmp[1]*src[1] + tmp[2]*src[2] + tmp[5]*src[3];
    dst[4] -= tmp[0]*src[1] + tmp[3]*src[2] + tmp[4]*src[3];
    dst[5] = tmp[0]*src[0] + tmp[7]*src[2] + tmp[8]*src[3];
    dst[5] -= tmp[1]*src[0] + tmp[6]*src[2] + tmp[9]*src[3];
    dst[6] = tmp[3]*src[0] + tmp[6]*src[1] + tmp[11]*src[3];
    dst[6] -= tmp[2]*src[0] + tmp[7]*src[1] + tmp[10]*src[3];
    dst[7] = tmp[4]*src[0] + tmp[9]*src[1] + tmp[10]*src[2];
    dst[7] -= tmp[5]*src[0] + tmp[8]*src[1] + tmp[11]*src[2];
    tmp[0] = src[2]*src[7];
    tmp[1] = src[3]*src[6];
    tmp[2] = src[1]*src[7];
    tmp[3] = src[3]*src[5];
    tmp[4] = src[1]*src[6];
    tmp[5] = src[2]*src[5];
    tmp[6] = src[0]*src[7];
    tmp[7] = src[3]*src[4];
    tmp[8] = src[0]*src[6];
    tmp[9] = src[2]*src[4];
    tmp[10] = src[0]*src[5];
    tmp[11] = src[1]*src[4];
    dst[8] = tmp[0]*src[13] + tmp[3]*src[14] + tmp[4]*src[15];
    dst[8] -= tmp[1]*src[13] + tmp[2]*src[14] + tmp[5]*src[15];
    dst[9] = tmp[1]*src[12] + tmp[6]*src[14] + tmp[9]*src[15];
    dst[9] -= tmp[0]*src[12] + tmp[7]*src[14] + tmp[8]*src[15];
    dst[10] = tmp[2]*src[12] + tmp[7]*src[13] + tmp[10]*src[15];
    dst[10]-= tmp[3]*src[12] + tmp[6]*src[13] + tmp[11]*src[15];
    dst[11] = tmp[5]*src[12] + tmp[8]*src[13] + tmp[11]*src[14];
    dst[11]-= tmp[4]*src[12] + tmp[9]*src[13] + tmp[10]*src[14];
    dst[12] = tmp[2]*src[10] + tmp[5]*src[11] + tmp[1]*src[9];
    dst[12]-= tmp[4]*src[11] + tmp[0]*src[9] + tmp[3]*src[10];
    dst[13] = tmp[8]*src[11] + tmp[0]*src[8] + tmp[7]*src[10];
    dst[13]-= tmp[6]*src[10] + tmp[9]*src[11] + tmp[1]*src[8];
    dst[14] = tmp[6]*src[9] + tmp[11]*src[11] + tmp[3]*src[8];
    dst[14]-= tmp[10]*src[11] + tmp[2]*src[8] + tmp[7]*src[9];
    dst[15] = tmp[10]*src[10] + tmp[4]*src[8] + tmp[9]*src[9];
    dst[15]-= tmp[8]*src[9] + tmp[11]*src[10] + tmp[5]*src[8];
    det = src[0]*dst[0]+src[1]*dst[1]+src[2]*dst[2]+src[3]*dst[3];
    det = 1.0f/det;
    for(int j = 0; j < 16; j++){dst[j] *= det;}
}
void mTranspose(mat *r, const mat *m)
{
    r->m[0][0] = m->m[0][0];
    r->m[1][0] = m->m[0][1];
    r->m[2][0] = m->m[0][2];
    r->m[3][0] = m->m[0][3];
    r->m[0][1] = m->m[1][0];
    r->m[1][1] = m->m[1][1];
    r->m[2][1] = m->m[1][2];
    r->m[3][1] = m->m[1][3];
    r->m[0][2] = m->m[2][0];
    r->m[1][2] = m->m[2][1];
    r->m[2][2] = m->m[2][2];
    r->m[3][2] = m->m[2][3];
    r->m[0][3] = m->m[3][0];
    r->m[1][3] = m->m[3][1];
    r->m[2][3] = m->m[3][2];
    r->m[3][3] = m->m[3][3];
}
void mSetViewDir(mat *r, const vec dir_norm)
{
    static const vec up_norm = (vec){0.f, 0.f, 1.f};
    vec c;
    vCross(&c, up_norm, dir_norm);
    vNorm(&c);
    vec rup;
    vCross(&rup, dir_norm, c);
    r->m[0][0] = -c.x;
    r->m[1][0] = -c.y;
    r->m[2][0] = -c.z;
    r->m[0][1] = -rup.x;
    r->m[1][1] = -rup.y;
    r->m[2][1] = -rup.z;
    r->m[0][2] = -dir_norm.x;
    r->m[1][2] = -dir_norm.y;
    r->m[2][2] = -dir_norm.z;
}
void mGetViewDir(vec *r, const mat matrix)
{
    mGetViewZ(r, matrix);
}
void mGetViewX(vec *r, const mat matrix)
{
    r->x = -matrix.m[0][0];
    r->y = -matrix.m[1][0];
    r->z = -matrix.m[2][0];
}
void mGetViewY(vec *r, const mat matrix)
{
    r->x = -matrix.m[0][1];
    r->y = -matrix.m[1][1];
    r->z = -matrix.m[2][1];
}
void mGetViewZ(vec *r, const mat matrix)
{
    r->x = -matrix.m[0][2];
    r->y = -matrix.m[1][2];
    r->z = -matrix.m[2][2];
}
void mSetDir(mat *r, const vec dir_norm)
{
    static const vec up_norm = (vec){0.f, 0.f, 1.f};
    vec c;
    vCross(&c, up_norm, dir_norm);
    vNorm(&c);
    vec rup;
    vCross(&rup, dir_norm, c);
    r->m[0][0] = c.x;
    r->m[0][1] = c.y;
    r->m[0][2] = c.z;
    r->m[2][0] = rup.x;
    r->m[2][1] = rup.y;
    r->m[2][2] = rup.z;
    r->m[1][0] = -dir_norm.x;
    r->m[1][1] = -dir_norm.y;
    r->m[1][2] = -dir_norm.z;
}
void mGetDirX(vec *r, const mat matrix)
{
    r->x = matrix.m[0][0];
    r->y = matrix.m[0][1];
    r->z = matrix.m[0][2];
}
void mGetDirY(vec *r, const mat matrix)
{
    r->x = matrix.m[1][0];
    r->y = matrix.m[1][1];
    r->z = matrix.m[1][2];
}
void mGetDirZ(vec *r, const mat matrix)
{
    r->x = matrix.m[2][0];
    r->y = matrix.m[2][1];
    r->z = matrix.m[2][2];
}
void mGetPos(vec *r, const mat matrix)
{
    r->x = matrix.m[3][0];
    r->y = matrix.m[3][1];
    r->z = matrix.m[3][2];
}
void mSetPos(mat *r, const vec pos)
{
    r->m[3][0] = pos.x;
    r->m[3][1] = pos.y;
    r->m[3][2] = pos.z;
}
void mDump(const mat matrix)
{
    printf("%+.2f %+.2f %+.2f %+.2f\n", matrix.m[0][0], matrix.m[0][1], matrix.m[0][2], matrix.m[0][3]);
    printf("%+.2f %+.2f %+.2f %+.2f\n", matrix.m[1][0], matrix.m[1][1], matrix.m[1][2], matrix.m[1][3]);
    printf("%+.2f %+.2f %+.2f %+.2f\n", matrix.m[2][0], matrix.m[2][1], matrix.m[2][2], matrix.m[2][3]);
    printf("%+.2f %+.2f %+.2f %+.2f\n", matrix.m[3][0], matrix.m[3][1], matrix.m[3][2], matrix.m[3][3]);
    printf("---\n");
}
float mGetRotX(const mat *m)
{
    return atan2f(-m->m[1][2], m->m[1][1]);
}
float mGetRotY(const mat *m)
{
    return atan2f(m->m[0][2], m->m[2][2]);
}
float mGetRotZ(const mat *m)
{
    return atan2f(m->m[1][0], m->m[0][0]);
}
void mSetRotX(mat *r, const float radians)
{
    const float s = sinf(radians);
    const float c = cosf(radians);
    r->m[0][0] = c;
    r->m[0][1] = 0.f;
    r->m[0][2] = s;
    r->m[0][3] = 0.f;
    r->m[1][0] = 0.f;
    r->m[1][1] = 1.f;
    r->m[1][2] = 0.f;
    r->m[1][3] = 0.f;
    r->m[2][0] = -s;
    r->m[2][1] = 0.f;
    r->m[2][2] = c;
    r->m[2][3] = 0.f;
}
void mSetRotY(mat *r, const float radians)
{
    const float s = sinf(radians);
    const float c = cosf(radians);
    r->m[0][0] = 1.f;
    r->m[0][1] = 0.f;
    r->m[0][2] = 0.f;
    r->m[0][3] = 0.f;
    r->m[1][0] = 0.f;
    r->m[1][1] = c;
    r->m[1][2] = -s;
    r->m[1][3] = 0.f;
    r->m[2][0] = 0.f;
    r->m[2][1] = s;
    r->m[2][2] = c;
    r->m[2][3] = 0.f;
}
void mSetRotZ(mat *r, const float radians)
{
    const float s = sinf(radians);
    const float c = cosf(radians);
    r->m[0][0] = c;
    r->m[0][1] = -s;
    r->m[0][2] = 0.f;
    r->m[0][3] = 0.f;
    r->m[1][0] = s;
    r->m[1][1] = c;
    r->m[1][2] = 0.f;
    r->m[1][3] = 0.f;
    r->m[2][0] = 0.f;
    r->m[2][1] = 0.f;
    r->m[2][2] = 1.f;
    r->m[2][3] = 0.f;
}