[vert.glsl]
#version 120

attribute vec3 in_Position;
attribute vec3 in_Normal;
attribute vec4 in_Color;
attribute vec2 in_TexCoord;

uniform mat4 u_modelview;
uniform mat4 u_view;
uniform mat4 u_projection;
uniform mat3 u_normalmat;

varying vec4 pass_Vertex; /* View space */
varying vec3 pass_TNormal;
varying vec4 pass_Color;
varying vec2 pass_TexCoord;

void main(void)
{
    vec4 vertex = u_modelview * vec4(in_Position, 1.0);
    vec3 tnorm = normalize(u_normalmat * in_Normal);

    pass_Vertex = vertex;
    pass_TNormal = tnorm;
    pass_Color = in_Color;
    pass_TexCoord = in_TexCoord;

    gl_Position = u_projection * vertex;
}

[frag.glsl]
#version 120

#if defined GL_ES
precision highp float;
#endif

uniform float in_Damage;
uniform mat4 u_view;
uniform mat4 u_inv_view;

uniform vec4 u_lights[8 * 2];

varying vec4 pass_Vertex; /* View space */
varying vec3 pass_TNormal;
varying vec4 pass_Color;
varying vec2 pass_TexCoord;

void main(void)
{
    float mode = 0.0;
    if (mode == 0.0)
    {
        gl_FragColor = vec4(mod(pass_TexCoord.x, 1.0),
                            0.1,
                            mod(pass_TexCoord.y, 1.0), 1.0);
    }
    else
    {
        float col = ((mod(mode, 2.0) == 1.0)?(mod(pass_TexCoord.x, 1.0)):(mod(pass_TexCoord.y, 1.0)));
        if (mode == 1.0 || mode == 2.0)
        {
            if (col > 1.0/3.0) gl_FragColor.r = 0.0;
            else gl_FragColor.r = min(col, 1.0/3.0);
            if (col > 2.0/3.0) gl_FragColor.g = 0.0;
            else gl_FragColor.g = min(max(col, 1.0/3.0) - 1.0/3.0, 1.0/3.0);
            gl_FragColor.b = min(max(col, 2.0/3.0) - 2.0/3.0, 1.0/3.0);
        }
        else if (mode == 3.0 || mode == 4.0)
        {
            if (col > 0.5) gl_FragColor.r = 0.0;
            else gl_FragColor.r = min(col, 0.5);
            gl_FragColor.g = min(max(col, 0.5) - 0.5, 0.5);
            gl_FragColor.b = 0.1;
        }
        else if (mode == 5.0 || mode == 6.0)
        {
            gl_FragColor.r = col;
            gl_FragColor.g = 0.1;
            gl_FragColor.b = 0.1;
        }
    }

    gl_FragColor.a = 1.0;
    gl_FragColor *=
                 //= pass_Color *
                    length(normalize(pass_TexCoord)) *
                    length(normalize(pass_Color.xyz)) *
                    length(normalize(pass_TNormal));
}

[vert.hlsl]

void main(float3 in_Vertex : POSITION,
          float3 in_Normal : NORMAL,
          float4 in_Color : COLOR,
          uniform float4x4 u_modelview,
          uniform float4x4 u_projection,
          uniform float3x3 u_normalmat,
          out float4 pass_Vertex : TEXCOORD0,
          out float3 pass_TNormal : TEXCOORD1,
          out float4 pass_Color : COLOR,
          out float4 out_Position : POSITION)
{
    float4 eye = mul(u_modelview, float4(in_Vertex, 1.0));
    float3 tnorm = normalize(mul(u_normalmat, in_Normal));

    pass_Vertex = eye;
    pass_TNormal = tnorm;
    pass_Color = in_Color;

    out_Position = mul(u_projection, eye);
}

[frag.hlsl]

void main(float4 pass_Vertex : TEXCOORD0,
          float3 pass_TNormal : TEXCOORD1,
          float4 pass_Color : COLOR,
          uniform float in_Damage,
          out float4 out_FragColor : COLOR)
{
    float3 in_LightDir = float3(0.3, 0.3, 0.7);

    /* Material properties */
    float3 specular_reflect = float3(0.8, 0.75, 0.4);
    float specular_power = 60.0;

    /* World properties */
    float ambient_mul = 0.5;
    float3 ambient_color = float3(0.25, 0.2, 0.35);
    float3 diffuse_color = float3(1.0, 1.0, 0.6);
    float3 specular_color = float3(1.0, 1.0, 0.6);

    float3 s = normalize(in_LightDir); /* normalize(pass_Vertex - lightpos); */
    float3 v = normalize(-pass_Vertex.xyz);
    float3 r = reflect(-s, pass_TNormal);

    float3 ambient = ambient_color;
    float sdotn = max(dot(s, pass_TNormal), 0.0);
    float3 diffuse = diffuse_color * sdotn;
    float3 specular = float3(0.0, 0.0, 0.0);
    if (sdotn > 0.0)
        specular = specular_color * specular_reflect
                 * pow(max(dot(r, v), 0.0), specular_power);
    float3 light = ambient + diffuse + specular;

    float4 real_color = in_Damage * float4(1.2, 1.2, 1.2, 1.0)
                      + (1.0 - in_Damage) * pass_Color;
    out_FragColor = real_color * float4(light, 1.0);
}